mirror of https://github.com/diegosouzapw/OmniRoute.git synced 2026-05-05 09:46:30 +00:00

History

diegosouzapw 5085dcf96f ci: fix sonarqube config and test suite failures		2026-04-06 18:11:09 -03:00
..
README.md	ci: fix sonarqube config and test suite failures	2026-04-06 18:11:09 -03:00

README.md

OmniRoute A2A Server (العربية)

🌐 Languages: 🇺🇸 English · 🇪🇸 es · 🇫🇷 fr · 🇩🇪 de · 🇮🇹 it · 🇷🇺 ru · 🇨🇳 zh-CN · 🇯🇵 ja · 🇰🇷 ko · 🇸🇦 ar · 🇮🇳 hi · 🇮🇳 in · 🇹🇭 th · 🇻🇳 vi · 🇮🇩 id · 🇲🇾 ms · 🇳🇱 nl · 🇵🇱 pl · 🇸🇪 sv · 🇳🇴 no · 🇩🇰 da · 🇫🇮 fi · 🇵🇹 pt · 🇷🇴 ro · 🇭🇺 hu · 🇧🇬 bg · 🇸🇰 sk · 🇺🇦 uk-UA · 🇮🇱 he · 🇵🇭 phi · 🇧🇷 pt-BR · 🇨🇿 cs · 🇹🇷 tr

Agent-to-Agent Protocol v0.3— يتزايد أي وكيل AI من استخدام OmniRoute كوكيل توجيه ذكي عبر JSON-RPC 2.0.

يعرض مضيف A2A OmniRouteوكيلًا من الدرجة الأولىيمكن لوكلاء الاكتشافات الأخرى وطلب الاتصال به باستخدام بروتوكول A2A.---## الهندسة

┌──────────────────────────────────────────────────────────────────┐
│                    Orchestrator Agent                             │
│        (LangChain, CrewAI, AutoGen, Custom Agent)                │
└──────────────────────┬───────────────────────────────────────────┘
                       │  1. GET /.well-known/agent.json  (discover)
                       │  2. POST /a2a  (JSON-RPC 2.0)
                       ▼
┌──────────────────────────────────────────────────────────────────┐
│                     OmniRoute A2A Server                         │
│  ┌────────────────┐  ┌────────────────┐  ┌───────────────────┐  │
│  │  Task Manager  │  │  Skill Engine  │  │  SSE Streaming    │  │
│  │  (lifecycle)   │──│  (registry)    │──│  (real-time)      │  │
│  └────────────────┘  └────────┬───────┘  └───────────────────┘  │
│                               │                                  │
│  Skills:                      │                                  │
│    ├─ smart-routing ──────────┤  ┌────────────────────────────┐  │
│    └─ quota-management ───────┘  │  Routing Decision Logger   │  │
│                                  └────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────┘
                       │
                       ▼  OmniRoute Gateway (internal)
              /v1/chat/completions, /api/combos, /api/usage/quota

بداية سريعة

Agent Discovery

يعرض كل وكيل متوافق مع A2Aبطاقة الوكيلعلى /.well-known/agent.json:bash حليقة http://localhost:20128/.well-known/agent.json

إجابة:```json { "name": "OmniRoute", "description": "Intelligent AI gateway with auto-routing across 50+ providers", "url": "http://localhost:20128/a2a", "version": "1.8.1", "capabilities": { "streaming": true, "pushNotifications": false }, "skills": [ { "id": "smart-routing", "name": "Smart Routing", "description": "Routes prompts through OmniRoute intelligent pipeline", "tags": ["routing", "llm", "multi-provider", "cost-optimization"], "examples": [ "Write a hello world in Python", "Explain quantum computing using the cheapest provider" ] }, { "id": "quota-management", "name": "Quota Management", "description": "Natural-language queries about provider quotas", "tags": ["quota", "analytics", "cost"], "examples": [ "Which provider has the most quota remaining?", "Suggest a free combo for coding" ] } ], "authentication": { "schemes": ["bearer"], "apiKeyHeader": "Authorization" } }


---

## JSON-RPC 2.0 Methods

### `message/send` — Synchronous Execution

أرسل رسالة إلى إحدى المهارات واحصل على الرد الكامل.```bash
حليقة -X POST http://localhost:20128/a2a \
  -H "نوع المحتوى: application/json" \
  -H "التفويض: حامل YOUR_KEY" \
  -د '{
    "jsonrpc": "2.0",
    "المعرف": "1"،
    "الطريقة": "رسالة/إرسال"،
    "المعلمات": {
      "المهارة": "التوجيه الذكي"،
      "messages": [{"role": "user", "content": "اكتب عالم بايثون المرحب"}],
      "بيانات التعريف": {"model": "auto"، "combo": "الترميز السريع"}
    }
  }'```

**إجابة:**```json
{
  "jsonrpc": "2.0",
  "id": "1",
  "result": {
    "task": { "id": "a1b2c3d4-...", "state": "completed" },
    "artifacts": [{ "type": "text", "content": "print('Hello, World!')" }],
    "metadata": {
      "routing_explanation": "Selected claude-sonnet via provider \"anthropic\" (latency: 1200ms, cost: $0.0030)",
      "cost_envelope": { "estimated": 0.005, "actual": 0.003, "currency": "USD" },
      "resilience_trace": [
        { "event": "primary_selected", "provider": "anthropic", "timestamp": "2026-03-04T..." }
      ],
      "policy_verdict": { "allowed": true, "reason": "within budget and quota limits" }
    }
  }
}

`message/stream` — SSE Streaming

نفس الرسالة/الإرسال ولكنها تُرجع الأحداث المرسلة من العميل للبث في الوقت الحقيقي.bash حليقة -N -X POST http://localhost:20128/a2a \ -H "نوع المحتوى: application/json" \ -H "التفويض: حامل YOUR_KEY" \ -د '{ "jsonrpc": "2.0", "المعرف": "1"، "الطريقة": "رسالة/دفق"، "المعلمات": { "المهارة": "التوجيه الذكي"، "messages": [{"role": "user", "content": "شرح الحوسبة الكمومية"}] } }'

أحداث SSE:```
data: {"jsonrpc":"2.0","method":"message/stream","params":{"task":{"id":"...","state":"working"},"chunk":{"type":"text","content":"Quantum computing..."}}}: heartbeat 2026-03-04T21:00:00Z

data: {"jsonrpc":"2.0","method":"message/stream","params":{"task":{"id":"...","state":"completed"},"metadata":{...}}}


### `tasks/get` — Query Task Status

```bash
curl -X POST http://localhost:20128/a2a \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_KEY" \
  -d '{"jsonrpc":"2.0","id":"2","method":"tasks/get","params":{"taskId":"TASK_UUID"}}'

`tasks/cancel` — Cancel a Running Task

curl -X POST http://localhost:20128/a2a \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_KEY" \
  -d '{"jsonrpc":"2.0","id":"3","method":"tasks/cancel","params":{"taskId":"TASK_UUID"}}'

Skills Reference

`smart-routing`

تطالب المسارات عبر خط الأنابيب OmniRoute الذكي مع إمكانية المراقبة الكاملة.

المعلمات (في البيانات الوصفية):

المعلمة	اكتب	افتراضي	الوصف
`نموذج`	"السلسلة"	`"تلقائي"`	النموذج المستهدف (على سبيل المثال، `clude-sonnet-4`، `gpt-4o`، `auto`)
`التحرير والسرد`	"السلسلة"	التحرير والسرد لكم	التحرير والسرد للتوجيه من خلال
`الميزانية`	`الرقم`	لا شيء	الحد الأقصى للتكلفة بالدولار الأمريكي هذا الطلب
`دور`	"السلسلة"	لا شيء	تلميح مهم: `التميز`، `المراجعة`، `التخطيط`، `التحليل`، `تصحيح سبب`، `التوثيق`

المرتجعات:

	الوصف
`المصنوعات[].content`	نصرد LLM
`metadata.routing_explanation`	شرح مفهوم لقرار التوجيه
`metadata.cost_envelope`	التكلفة المقدرة مقابل تكلفة التكلفة للعملة
`metadata.resilience_trace`	مصفوفة من الأحداث (تم تحديدها بشكل أساسي، والمطلوبة بديلاً، وما إلى ذلك)
`metadata.policy_verdict`	ما إذا كان ائداً لها لسبب	### `إدارة الحصص`

يجيب على استفسارات اللغة الطبيعية حول حصص الموفرين.

أنواع اتفق (المنتهية من محتوى الرسالة):

نمط	نوع المصدر
يحتوي على `"التصنيف"`، `"الأكثر حصة"`، `"الأفضل"`	تم ترتيب مقدمي الخدمة حسب الحصص النهائية
يحتوي على `"مجاني"`، `"اقتراح"`	يسرد المهرجانات أو المهرجانات المجانية
افتراضي	ملخص كامل للحصص مع تحذيرات للحصص المنخفضة	---## Task Lifecycle

submitted ──→ working ──→ completed
                       ──→ failed
              ──────────→ cancelled

الدولة	الوصف
`مُقدم`	تم إنشاء المهمة، في قائمة الانتظار للتنفيذ
`العمل`	معالج المهارة ينفذ
`مكتملة`	البدء في التنفيذ، القطع الأثرية الصعبة
`فشل`	فشل التنفيذ أو النهاية إلى النهاية (TTL: 5 بالضغط الافتراضي)
`ملغاة`	تم الإلغاء من قبل العميل عبر `المهام/الإلغاء`

حالات الوحدة الطرفية: مكتملة، فشل، ملغى (لم تحدث عمليات انتقال أخرى)
يتم وضع العلامة التجارية الجديدة على انتهاء الصلاحية في "المقدمة" أو "الجاري" على أنها "فاشلة".
يتم جمع المهام المهمة بعد 2 × TTL---## Client Examples

Python — Orchestrator Agent

"""
A2A Client — Python example.
Discovers OmniRoute agent, sends a task, and processes the result.
"""
import requests
import json

BASE_URL = "http://localhost:20128"
API_KEY = "your-api-key"
HEADERS = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}",
}

# 1. Discover agent capabilities
agent_card = requests.get(f"{BASE_URL}/.well-known/agent.json").json()
print(f"Agent: {agent_card['name']} v{agent_card['version']}")
print(f"Skills: {[s['id'] for s in agent_card['skills']]}")

# 2. Send a smart-routing task
response = requests.post(f"{BASE_URL}/a2a", headers=HEADERS, json={
    "jsonrpc": "2.0",
    "id": "task-1",
    "method": "message/send",
    "params": {
        "skill": "smart-routing",
        "messages": [{"role": "user", "content": "Write a Python quicksort implementation"}],
        "metadata": {
            "model": "auto",
            "combo": "fast-coding",
            "budget": 0.10,
        }
    }
})
result = response.json()["result"]
print(f"\n📝 Response: {result['artifacts'][0]['content'][:200]}...")
print(f"🔀 Routing: {result['metadata']['routing_explanation']}")
print(f"💰 Cost: ${result['metadata']['cost_envelope']['actual']}")
print(f"🛡️ Policy: {result['metadata']['policy_verdict']['reason']}")

# 3. Query quota status
quota_resp = requests.post(f"{BASE_URL}/a2a", headers=HEADERS, json={
    "jsonrpc": "2.0",
    "id": "task-2",
    "method": "message/send",
    "params": {
        "skill": "quota-management",
        "messages": [{"role": "user", "content": "Which provider has the most quota remaining?"}],
    }
})
quota_result = quota_resp.json()["result"]
print(f"\n📊 Quota: {quota_result['artifacts'][0]['content']}")

TypeScript — Multi-Agent Orchestrator

/**
 * A2A Client — TypeScript example.
 * Shows agent discovery, task delegation, and streaming.
 */

const BASE_URL = "http://localhost:20128";
const API_KEY = "your-api-key";

interface JsonRpcResponse<T = any> {
  jsonrpc: "2.0";
  id: string | number;
  result?: T;
  error?: { code: number; message: string };
}

async function a2aCall<T>(method: string, params: Record<string, any>): Promise<T> {
  const resp = await fetch(`${BASE_URL}/a2a`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${API_KEY}`,
    },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: `${method}-${Date.now()}`,
      method,
      params,
    }),
  });
  const json: JsonRpcResponse<T> = await resp.json();
  if (json.error) throw new Error(`[${json.error.code}] ${json.error.message}`);
  return json.result!;
}

// ── Agent Discovery ──
const agentCard = await fetch(`${BASE_URL}/.well-known/agent.json`).then((r) => r.json());
console.log(`Connected to: ${agentCard.name} (${agentCard.skills.length} skills)`);

// ── Smart Routing: Send a coding task ──
const routingResult = await a2aCall("message/send", {
  skill: "smart-routing",
  messages: [{ role: "user", content: "Implement a Redis cache wrapper in TypeScript" }],
  metadata: { model: "claude-sonnet-4", role: "coding" },
});
console.log("Response:", routingResult.artifacts[0].content);
console.log("Provider:", routingResult.metadata.routing_explanation);

// ── Quota Management: Find free alternatives ──
const quotaResult = await a2aCall("message/send", {
  skill: "quota-management",
  messages: [{ role: "user", content: "Suggest free combos for documentation" }],
});
console.log("Free combos:", quotaResult.artifacts[0].content);

// ── Streaming: Real-time response ──
const streamResp = await fetch(`${BASE_URL}/a2a`, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${API_KEY}`,
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: "stream-1",
    method: "message/stream",
    params: {
      skill: "smart-routing",
      messages: [{ role: "user", content: "Explain microservices architecture" }],
    },
  }),
});

const reader = streamResp.body!.getReader();
const decoder = new TextDecoder();
while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  const chunk = decoder.decode(value);
  for (const line of chunk.split("\n")) {
    if (line.startsWith("data: ")) {
      const event = JSON.parse(line.slice(6));
      if (event.params.chunk) {
        process.stdout.write(event.params.chunk.content);
      }
      if (event.params.task.state === "completed") {
        console.log("\n✅ Stream completed");
      }
    }
  }
}

Python — LangChain A2A Integration

"""
LangChain integration — Use OmniRoute A2A as a custom LLM.
"""
from langchain.llms.base import BaseLLM
from langchain.schema import LLMResult, Generation
import requests
from typing import List, Optional

class OmniRouteA2A(BaseLLM):
    base_url: str = "http://localhost:20128"
    api_key: str = ""
    model: str = "auto"
    combo: Optional[str] = None

    @property
    def _llm_type(self) -> str:
        return "omniroute-a2a"

    def _call(self, prompt: str, stop: Optional[List[str]] = None, **kwargs) -> str:
        response = requests.post(
            f"{self.base_url}/a2a",
            headers={
                "Content-Type": "application/json",
                "Authorization": f"Bearer {self.api_key}",
            },
            json={
                "jsonrpc": "2.0",
                "id": "langchain-1",
                "method": "message/send",
                "params": {
                    "skill": "smart-routing",
                    "messages": [{"role": "user", "content": prompt}],
                    "metadata": {
                        "model": self.model,
                        **({"combo": self.combo} if self.combo else {}),
                    },
                },
            },
        )
        result = response.json()["result"]
        return result["artifacts"][0]["content"]

    def _generate(self, prompts: List[str], stop=None, **kwargs) -> LLMResult:
        return LLMResult(
            generations=[[Generation(text=self._call(p, stop))] for p in prompts]
        )

# Usage
llm = OmniRouteA2A(
    base_url="http://localhost:20128",
    api_key="your-key",
    model="auto",
    combo="fast-coding",
)
result = llm("Write a Python function to merge two sorted lists")
print(result)

Go — A2A Client

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

const baseURL = "http://localhost:20128"
const apiKey = "your-api-key"

type JsonRpcRequest struct {
	Jsonrpc string      `json:"jsonrpc"`
	ID      string      `json:"id"`
	Method  string      `json:"method"`
	Params  interface{} `json:"params"`
}

type JsonRpcResponse struct {
	Jsonrpc string      `json:"jsonrpc"`
	ID      string      `json:"id"`
	Result  interface{} `json:"result"`
	Error   *struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
	} `json:"error"`
}

func a2aCall(method string, params interface{}) (*JsonRpcResponse, error) {
	body, _ := json.Marshal(JsonRpcRequest{
		Jsonrpc: "2.0",
		ID:      "go-1",
		Method:  method,
		Params:  params,
	})

	req, _ := http.NewRequest("POST", baseURL+"/a2a", bytes.NewReader(body))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+apiKey)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	data, _ := io.ReadAll(resp.Body)

	var result JsonRpcResponse
	json.Unmarshal(data, &result)
	return &result, nil
}

func main() {
	// Discover agent
	resp, _ := http.Get(baseURL + "/.well-known/agent.json")
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println("Agent Card:", string(body))

	// Send smart-routing task
	result, _ := a2aCall("message/send", map[string]interface{}{
		"skill":    "smart-routing",
		"messages": []map[string]string{{"role": "user", "content": "Hello from Go!"}},
		"metadata": map[string]interface{}{"model": "auto"},
	})
	out, _ := json.MarshalIndent(result.Result, "", "  ")
	fmt.Println("Result:", string(out))
}

Use Cases

🤖 Use Case 1: Multi-Agent Coding Pipeline

يقوم وكيل منسق بتفويض إنشاء تعليمات الحظر إلى OmniRoute، ثم يقوم بتمرير الترخيص لوكيل التعديل.```python تعريف coding_pipeline (المهمة: str): # الخطوة 1: قم بإنشاء الكود عبر OmniRoute A2A code_result = a2a_send("التوجيه الذكي"، [ {"role": "user"، "content": f"اكتب كود جودة الإنتاج: {task}"} ]، البيانات الوصفية={"model": "auto"، "role": "coding"}) كود = code_result["artifacts"][0]["content"]

# الخطوة الثانية: قم بمراجعة الكود عبر OmniRoute A2A (نموذج مختلف)
review_result = a2a_send("التوجيه الذكي"، [
    {"role": "user"، "content": f"راجع هذا الرمز بحثًا عن الأخطاء والتحسينات:\n\n{code}"}
]، البيانات الوصفية={"model": "auto"، "role": "review"})
المراجعة = review_result["artifacts"][0]["content"]

# الخطوة 3: التحقق من التكاليف
print(f"تكلفة الكود: ${code_result['metadata']['cost_envelope']['actual']}")
print(f"تكلفة المراجعة: ${review_result['metadata']['cost_envelope']['actual']}")

إرجاع {"كود": كود، "مراجعة": مراجعة}```

💡 Use Case 2: Quota-Aware Agent Swarm

يقوم العديد من الوكلاء بمشاركة الحصص من خلال OmniRoute، وذلك باستخدام مهارة الحصص للتنسيق.```python async def quota_aware_agent(agent_name: str, task: str): # Check quota before starting quota = a2a_send("quota-management", [ {"role": "user", "content": "Which provider has the most quota remaining?"} ]) print(f"[{agent_name}] {quota['artifacts'][0]['content']}")

# Send request with budget constraint
result = a2a_send("smart-routing", [
    {"role": "user", "content": task}
], metadata={"budget": 0.05})

policy = result["metadata"]["policy_verdict"]
if not policy["allowed"]:
    print(f"[{agent_name}] ⚠️ Budget exceeded: {policy['reason']}")
    # Fall back to free combo
    quota = a2a_send("quota-management", [
        {"role": "user", "content": "Suggest free combos"}
    ])
    print(f"[{agent_name}] Free alternatives: {quota['artifacts'][0]['content']}")

return result


### 📊 Use Case 3: Real-Time Streaming Dashboard

يقوم بالمراقبة ببث الاستجابات ويعرض التقدم في الوقت الفعلي.```typescript
وظيفة غير متزامنة StreamDashboard(prompt: string) {
  استجابة ثابتة = انتظار الجلب(`${BASE_URL}/a2a`, {
    الطريقة: "POST"،
    الرؤوس: { "نوع المحتوى": "application/json"، التفويض: `Bearer ${API_KEY}` }،
    الجسم: JSON.stringify({
      جسونربك: "2.0"،
      المعرف: "داش-1"،
      الطريقة: "رسالة/دفق"،
      المعلمات: { المهارة: "التوجيه الذكي"، الرسائل: [{ الدور: "المستخدم"، المحتوى: موجه }] }،
    }),
  });

  دع مجموع القطع = 0؛
  قارئ ثابت = استجابة. الجسم!.getReader();
  const decoder = new TextDecoder();

  بينما (صحيح) {
    const { تم، القيمة } = انتظار Reader.read();
    إذا (تم) كسر؛

    for (سطر ثابت من decoder.decode(value).split("\n")) {
      إذا (line.startsWith("البيانات:")) {
        حدث const = JSON.parse(line.slice(6));
        حالة ثابتة = Event.params.task.state;

        إذا (الحالة === "العمل" && events.params.chunk) {
          TotalChunks++;
          عملية.stdout.write(
            `\r[قطعة ${totalChunks}] ${event.params.chunk.content.slice(0, 50)}...`
          );
        }
        إذا (الحالة === "مكتملة") {
          const meta = events.params.metadata;
          console.log(
            `\n ✅ تم | التكلفة: $${meta?.cost_envelope?.actual || 0} | الطريق: ${meta?.routing_explanation || "غير متوفر"}`
          );
        }
        إذا (الحالة === "فشل") {
          console.error(`\n❌ Failed: ${event.params.metadata?.error}`);
        }
      }
    }
  }
}```

### 🔁 Use Case 4: Task Polling Pattern

بالنسبة للمهام طويلة الأمد، قم باستقصاء حالة المهمة بدلاً من الانتظار بشكل متزامن.```python
import time

def poll_task(task_id: str, timeout: int = 60):
    """Poll task status until completion or timeout."""
    start = time.time()
    while time.time() - start < timeout:
        result = requests.post(f"{BASE_URL}/a2a", headers=HEADERS, json={
            "jsonrpc": "2.0",
            "id": "poll-1",
            "method": "tasks/get",
            "params": {"taskId": task_id},
        }).json()

        task = result["result"]["task"]
        state = task["state"]
        print(f"  Task {task_id[:8]}... state={state}")

        if state in ("completed", "failed", "cancelled"):
            return task
        time.sleep(2)

    # Timeout — cancel the task
    requests.post(f"{BASE_URL}/a2a", headers=HEADERS, json={
        "jsonrpc": "2.0",
        "id": "cancel-1",
        "method": "tasks/cancel",
        "params": {"taskId": task_id},
    })
    raise TimeoutError(f"Task {task_id} timed out after {timeout}s")

Error Codes

الكود	ثابت	معنى
-32700	—	خطأ في التحليل (JSON غير صالح)
-32600	`طلب_غير صالح`	طلب JSON-RPC غير صالح أو	غير مصرح به
-32601	`METHOD_NOT_FOUND`	طريقة أو مهارة غير معروفة
-32602	`INVALID_PARAMS`	معلمات مفقودة أو غير صالحة
-32603	`خطأ_داخلي`	فشل في تنفيذ المهارة
-32001	`مهمة_لم يتم العثور عليها`	لم يتم العثور على المفتاح الرئيسي
-32002	`المهمة_الجاهزة_مكتملة`	لا يمكن تعديل مهمة مكتملة
-32003	"غير مصرح به"	API الرئيسية غير صالحة أو مفقودة
-32004	`الميزانية_تجاوزت`	التجاوز المدى المكمل
-32005	`PROVIDER_UNAVAILABLE`	لا يوجد مقدمي خيارات الأسهم	---## Authentication

تتطلب جميع الطلبات /a2a رمزًا مميزًا لحاملها عبر الرأس الإعلان: التفويض: الحامل YOUR_OMNIROUTE_API_KEY

إذا لم يتم تكوين أي مفتاح API على الخادم (OMNIROUTE_API_KEY فارغ)، فسيتم تجاوز المصادقة.---

File Structure

سرك/ليب/a2a/
├── TaskManager.ts # دورة حياة المهمة (إنشاء/تحديث/إلغاء/قائمة)، TTL، تنظيف
├── TaskExecution.ts # منفذ المهام العامة مع إدارة الحالة
├── Stream.ts # تنسيق دفق SSE، ونبضات القلب، وأحداث القطعة/الإكمال
├── routingLogger.ts # مسجل قرار التوجيه (الإحصائيات والتاريخ والاحتفاظ)
└── المهارات/
    ├── SmartRouting.ts # مهارة التوجيه الذكي (الطرق عبر /v1/chat/completions)
    └── quotaManagement.ts # مهارة إدارة الحصص (استعلامات الحصص باللغة الطبيعية)

سرك/التطبيق/a2a/
└── Route.ts # معالج مسار واجهة برمجة التطبيقات Next.js (إرسال JSON-RPC 2.0)

مفتوح-SSE/MCP-خادم/
└── schemas/a2a.ts # مخططات Zod (AgentCard، Task، JSON-RPC، أحداث SSE)```

---

## Comparison: MCP vs A2A

| ميزة | خادم MCP | خادم A2A |
| ----------------- | ---------------------------- | ------------------------------------------------- |
|**البروتوكول**| بروتوكول السياق النموذجي | بروتوكول وكيل إلى وكيل v0.3 |
|**النقل**| ستديو / HTTP | HTTP (JSON-RPC 2.0) |
|**الاكتشاف**| قائمة الأدوات عبر MCP | `/.well-known/agent.json` |
|**التفاصيل**| 16 أداة فردية | 2 مهارات عالية المستوى |
|**الأفضل لـ**| وكلاء IDE (المؤشر، كود VS) | أنظمة متعددة الوكلاء (LangChain، CrewAI) |
|**البث**| غير مدعوم | SSE عبر "الرسالة/الدفق" |
|**تتبع المهام**| لا | دورة حياة كاملة (مقدمة → مكتملة) |
|**الملاحظة**| سجل التدقيق لكل استدعاء أداة | مظروف التكلفة + تتبع المرونة + حكم السياسة |---

## الرخصة

جزء من [OmniRoute](https://github.com/diegosouzapw/OmniRoute) - ترخيص معهد ماساتشوستس للتكنولوجيا.

README.md Unescape Escape