@radaros/core 0.1.0 → 0.3.0

package/dist/index.js

@@ -199,14 +199,22 @@ var ToolExecutor = class {
     const { zodToJsonSchema } = _require("zod-to-json-schema");
     const defs = [];
     for (const tool of this.tools.values()) {
-      const jsonSchema = zodToJsonSchema(tool.parameters, {
-        target: "openApi3"
-      });
-      defs.push({
-        name: tool.name,
-        description: tool.description,
-        parameters: jsonSchema
-      });
+      if (tool.rawJsonSchema) {
+        defs.push({
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.rawJsonSchema
+        });
+      } else {
+        const jsonSchema = zodToJsonSchema(tool.parameters, {
+          target: "openApi3"
+        });
+        defs.push({
+          name: tool.name,
+          description: tool.description,
+          parameters: jsonSchema
+        });
+      }
     }
     return defs;
   }
@@ -2359,6 +2367,291 @@ var OllamaProvider = class {
   }
 };
 
+// src/models/providers/vertex.ts
+import { createRequire as createRequire7 } from "module";
+var _require7 = createRequire7(import.meta.url);
+var VertexAIProvider = class {
+  providerId = "vertex";
+  modelId;
+  ai = null;
+  GoogleGenAICtor;
+  project;
+  location;
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.project = config?.project ?? process.env.GOOGLE_CLOUD_PROJECT ?? process.env.GCLOUD_PROJECT ?? "";
+    this.location = config?.location ?? process.env.GOOGLE_CLOUD_LOCATION ?? process.env.GOOGLE_CLOUD_REGION ?? "us-central1";
+    if (!this.project) {
+      throw new Error(
+        "VertexAIProvider: 'project' is required. Pass it in config or set GOOGLE_CLOUD_PROJECT env var."
+      );
+    }
+    try {
+      const { GoogleGenAI } = _require7("@google/genai");
+      this.GoogleGenAICtor = GoogleGenAI;
+    } catch {
+      throw new Error(
+        "@google/genai is required for VertexAIProvider. Install it: npm install @google/genai"
+      );
+    }
+  }
+  getClient() {
+    if (this.ai) return this.ai;
+    this.ai = new this.GoogleGenAICtor({
+      vertexai: true,
+      project: this.project,
+      location: this.location
+    });
+    return this.ai;
+  }
+  async generate(messages, options) {
+    const { systemInstruction, contents } = this.toGoogleMessages(messages);
+    const config = {};
+    if (options?.temperature !== void 0)
+      config.temperature = options.temperature;
+    if (options?.maxTokens !== void 0)
+      config.maxOutputTokens = options.maxTokens;
+    if (options?.topP !== void 0) config.topP = options.topP;
+    if (options?.stop) config.stopSequences = options.stop;
+    if (options?.responseFormat) {
+      config.responseMimeType = "application/json";
+      const rf = options.responseFormat;
+      if (typeof rf === "object" && rf !== null && "type" in rf && rf.type === "json_schema" && "schema" in rf && rf.schema) {
+        config.responseSchema = this.cleanJsonSchema(
+          rf.schema
+        );
+      }
+    }
+    const params = {
+      model: this.modelId,
+      contents,
+      config
+    };
+    if (systemInstruction) params.systemInstruction = systemInstruction;
+    if (options?.tools?.length) {
+      params.tools = [
+        { functionDeclarations: this.toGoogleTools(options.tools) }
+      ];
+    }
+    const client = this.getClient();
+    const response = await client.models.generateContent(params);
+    return this.normalizeResponse(response);
+  }
+  async *stream(messages, options) {
+    const { systemInstruction, contents } = this.toGoogleMessages(messages);
+    const config = {};
+    if (options?.temperature !== void 0)
+      config.temperature = options.temperature;
+    if (options?.maxTokens !== void 0)
+      config.maxOutputTokens = options.maxTokens;
+    if (options?.topP !== void 0) config.topP = options.topP;
+    if (options?.stop) config.stopSequences = options.stop;
+    const params = {
+      model: this.modelId,
+      contents,
+      config
+    };
+    if (systemInstruction) params.systemInstruction = systemInstruction;
+    if (options?.tools?.length) {
+      params.tools = [
+        { functionDeclarations: this.toGoogleTools(options.tools) }
+      ];
+    }
+    const client = this.getClient();
+    const streamResult = await client.models.generateContentStream(params);
+    let toolCallCounter = 0;
+    for await (const chunk of streamResult) {
+      const candidate = chunk.candidates?.[0];
+      if (!candidate?.content?.parts) continue;
+      for (const part of candidate.content.parts) {
+        if (part.text) {
+          yield { type: "text", text: part.text };
+        }
+        if (part.functionCall) {
+          const id = `vertex_tc_${toolCallCounter++}`;
+          yield {
+            type: "tool_call_start",
+            toolCall: { id, name: part.functionCall.name }
+          };
+          yield {
+            type: "tool_call_delta",
+            toolCallId: id,
+            argumentsDelta: JSON.stringify(part.functionCall.args ?? {})
+          };
+          yield { type: "tool_call_end", toolCallId: id };
+        }
+      }
+      if (candidate.finishReason) {
+        let finishReason = "stop";
+        if (candidate.finishReason === "STOP" || candidate.finishReason === "END_TURN")
+          finishReason = "stop";
+        else if (candidate.finishReason === "MAX_TOKENS")
+          finishReason = "length";
+        else if (candidate.finishReason === "SAFETY")
+          finishReason = "content_filter";
+        const hasToolCalls = candidate.content?.parts?.some(
+          (p) => p.functionCall
+        );
+        if (hasToolCalls) finishReason = "tool_calls";
+        yield {
+          type: "finish",
+          finishReason,
+          usage: chunk.usageMetadata ? {
+            promptTokens: chunk.usageMetadata.promptTokenCount ?? 0,
+            completionTokens: chunk.usageMetadata.candidatesTokenCount ?? 0,
+            totalTokens: chunk.usageMetadata.totalTokenCount ?? 0
+          } : void 0
+        };
+      }
+    }
+  }
+  // ── Message conversion (identical to GoogleProvider) ─────────────────────
+  toGoogleMessages(messages) {
+    let systemInstruction;
+    const contents = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        systemInstruction = getTextContent(msg.content) || void 0;
+        continue;
+      }
+      if (msg.role === "user") {
+        if (isMultiModal(msg.content)) {
+          contents.push({
+            role: "user",
+            parts: msg.content.map((p) => this.partToGoogle(p))
+          });
+        } else {
+          contents.push({
+            role: "user",
+            parts: [{ text: msg.content ?? "" }]
+          });
+        }
+        continue;
+      }
+      if (msg.role === "assistant") {
+        const parts = [];
+        if (msg.content) parts.push({ text: msg.content });
+        if (msg.toolCalls) {
+          for (const tc of msg.toolCalls) {
+            parts.push({
+              functionCall: { name: tc.name, args: tc.arguments }
+            });
+          }
+        }
+        if (parts.length === 0) parts.push({ text: "" });
+        contents.push({ role: "model", parts });
+        continue;
+      }
+      if (msg.role === "tool") {
+        contents.push({
+          role: "function",
+          parts: [
+            {
+              functionResponse: {
+                name: msg.name ?? "unknown",
+                response: { result: msg.content ?? "" }
+              }
+            }
+          ]
+        });
+        continue;
+      }
+    }
+    return { systemInstruction, contents };
+  }
+  partToGoogle(part) {
+    switch (part.type) {
+      case "text":
+        return { text: part.text };
+      case "image":
+      case "audio":
+      case "file": {
+        const isUrl = part.data.startsWith("http://") || part.data.startsWith("https://");
+        if (isUrl) {
+          return {
+            fileData: {
+              fileUri: part.data,
+              mimeType: part.mimeType ?? (part.type === "image" ? "image/png" : "application/octet-stream")
+            }
+          };
+        }
+        return {
+          inlineData: {
+            data: part.data,
+            mimeType: part.mimeType ?? (part.type === "image" ? "image/png" : part.type === "audio" ? "audio/mp3" : "application/octet-stream")
+          }
+        };
+      }
+    }
+  }
+  toGoogleTools(tools) {
+    return tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }));
+  }
+  cleanJsonSchema(schema) {
+    const cleaned = { ...schema };
+    delete cleaned["$schema"];
+    delete cleaned["$ref"];
+    delete cleaned["additionalProperties"];
+    if (cleaned.properties && typeof cleaned.properties === "object") {
+      const props = {};
+      for (const [key, val] of Object.entries(
+        cleaned.properties
+      )) {
+        props[key] = typeof val === "object" && val ? this.cleanJsonSchema(val) : val;
+      }
+      cleaned.properties = props;
+    }
+    if (cleaned.items && typeof cleaned.items === "object") {
+      cleaned.items = this.cleanJsonSchema(
+        cleaned.items
+      );
+    }
+    return cleaned;
+  }
+  normalizeResponse(response) {
+    const candidate = response.candidates?.[0];
+    const parts = candidate?.content?.parts ?? [];
+    let textContent = "";
+    const toolCalls = [];
+    let toolCallCounter = 0;
+    for (const part of parts) {
+      if (part.text) textContent += part.text;
+      if (part.functionCall) {
+        toolCalls.push({
+          id: `vertex_tc_${toolCallCounter++}`,
+          name: part.functionCall.name,
+          arguments: part.functionCall.args ?? {}
+        });
+      }
+    }
+    const usage = {
+      promptTokens: response.usageMetadata?.promptTokenCount ?? 0,
+      completionTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
+      totalTokens: response.usageMetadata?.totalTokenCount ?? 0
+    };
+    let finishReason = "stop";
+    if (toolCalls.length > 0) finishReason = "tool_calls";
+    else if (candidate?.finishReason === "MAX_TOKENS")
+      finishReason = "length";
+    else if (candidate?.finishReason === "SAFETY")
+      finishReason = "content_filter";
+    return {
+      message: {
+        role: "assistant",
+        content: textContent || null,
+        toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+      },
+      usage,
+      finishReason,
+      raw: response
+    };
+  }
+};
+
 // src/models/registry.ts
 var ModelRegistry = class {
   factories = /* @__PURE__ */ new Map();
@@ -2407,6 +2700,16 @@ function google(modelId, config) {
 function ollama(modelId, config) {
   return registry.resolve("ollama", modelId, config);
 }
+registry.register(
+  "vertex",
+  (modelId, config) => new VertexAIProvider(
+    modelId,
+    config
+  )
+);
+function vertex(modelId, config) {
+  return registry.resolve("vertex", modelId, config);
+}
 
 // src/tools/define-tool.ts
 function defineTool(config) {
@@ -2419,13 +2722,13 @@ function defineTool(config) {
 }
 
 // src/storage/sqlite.ts
-import { createRequire as createRequire7 } from "module";
-var _require7 = createRequire7(import.meta.url);
+import { createRequire as createRequire8 } from "module";
+var _require8 = createRequire8(import.meta.url);
 var SqliteStorage = class {
   db;
   constructor(dbPath) {
     try {
-      const Database = _require7("better-sqlite3");
+      const Database = _require8("better-sqlite3");
       this.db = new Database(dbPath);
       this.db.pragma("journal_mode = WAL");
       this.db.exec(`
@@ -2474,13 +2777,13 @@ var SqliteStorage = class {
 };
 
 // src/storage/postgres.ts
-import { createRequire as createRequire8 } from "module";
-var _require8 = createRequire8(import.meta.url);
+import { createRequire as createRequire9 } from "module";
+var _require9 = createRequire9(import.meta.url);
 var PostgresStorage = class {
   pool;
   constructor(connectionString) {
     try {
-      const { Pool } = _require8("pg");
+      const { Pool } = _require9("pg");
       this.pool = new Pool({ connectionString });
     } catch {
       throw new Error(
@@ -2541,15 +2844,15 @@ var PostgresStorage = class {
 };
 
 // src/storage/mongodb.ts
-import { createRequire as createRequire9 } from "module";
-var _require9 = createRequire9(import.meta.url);
+import { createRequire as createRequire10 } from "module";
+var _require10 = createRequire10(import.meta.url);
 var MongoDBStorage = class {
   constructor(uri, dbName = "radaros", collectionName = "kv_store") {
     this.uri = uri;
     this.dbName = dbName;
     this.collectionName = collectionName;
     try {
-      const { MongoClient } = _require9("mongodb");
+      const { MongoClient } = _require10("mongodb");
       this.client = new MongoClient(uri);
     } catch {
       throw new Error(
@@ -2709,8 +3012,8 @@ var InMemoryVectorStore = class extends BaseVectorStore {
 };
 
 // src/vector/pgvector.ts
-import { createRequire as createRequire10 } from "module";
-var _require10 = createRequire10(import.meta.url);
+import { createRequire as createRequire11 } from "module";
+var _require11 = createRequire11(import.meta.url);
 var PgVectorStore = class extends BaseVectorStore {
   pool;
   dimensions;
@@ -2719,7 +3022,7 @@ var PgVectorStore = class extends BaseVectorStore {
     super(embedder);
     this.dimensions = config.dimensions ?? embedder?.dimensions ?? 1536;
     try {
-      const { Pool } = _require10("pg");
+      const { Pool } = _require11("pg");
       this.pool = new Pool({ connectionString: config.connectionString });
     } catch {
       throw new Error(
@@ -2838,9 +3141,9 @@ var PgVectorStore = class extends BaseVectorStore {
 };
 
 // src/vector/qdrant.ts
-import { createRequire as createRequire11 } from "module";
+import { createRequire as createRequire12 } from "module";
 import { createHash } from "crypto";
-var _require11 = createRequire11(import.meta.url);
+var _require12 = createRequire12(import.meta.url);
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function stringToUUID(str) {
   const hex = createHash("md5").update(str).digest("hex");
@@ -2865,7 +3168,7 @@ var QdrantVectorStore = class extends BaseVectorStore {
     super(embedder);
     this.dimensions = config.dimensions ?? embedder?.dimensions ?? 1536;
     try {
-      const { QdrantClient } = _require11("@qdrant/js-client-rest");
+      const { QdrantClient } = _require12("@qdrant/js-client-rest");
       this.client = new QdrantClient({
         url: config.url ?? "http://localhost:6333",
         apiKey: config.apiKey,
@@ -2998,8 +3301,8 @@ var QdrantVectorStore = class extends BaseVectorStore {
 };
 
 // src/vector/mongodb.ts
-import { createRequire as createRequire12 } from "module";
-var _require12 = createRequire12(import.meta.url);
+import { createRequire as createRequire13 } from "module";
+var _require13 = createRequire13(import.meta.url);
 var MongoDBVectorStore = class extends BaseVectorStore {
   client;
   db;
@@ -3011,7 +3314,7 @@ var MongoDBVectorStore = class extends BaseVectorStore {
     this.indexName = config.indexName ?? "vector_index";
     this.dbName = config.dbName ?? "radaros_vectors";
     try {
-      const { MongoClient } = _require12("mongodb");
+      const { MongoClient } = _require13("mongodb");
       this.client = new MongoClient(config.uri);
     } catch {
       throw new Error(
@@ -3182,8 +3485,8 @@ function cosine(a, b) {
 }
 
 // src/vector/embeddings/openai.ts
-import { createRequire as createRequire13 } from "module";
-var _require13 = createRequire13(import.meta.url);
+import { createRequire as createRequire14 } from "module";
+var _require14 = createRequire14(import.meta.url);
 var MODEL_DIMENSIONS = {
   "text-embedding-3-small": 1536,
   "text-embedding-3-large": 3072,
@@ -3197,7 +3500,7 @@ var OpenAIEmbedding = class {
     this.model = config.model ?? "text-embedding-3-small";
     this.dimensions = config.dimensions ?? MODEL_DIMENSIONS[this.model] ?? 1536;
     try {
-      const mod = _require13("openai");
+      const mod = _require14("openai");
       const OpenAI = mod.default ?? mod;
       this.client = new OpenAI({
         apiKey: config.apiKey ?? process.env.OPENAI_API_KEY,
@@ -3228,8 +3531,8 @@ var OpenAIEmbedding = class {
 };
 
 // src/vector/embeddings/google.ts
-import { createRequire as createRequire14 } from "module";
-var _require14 = createRequire14(import.meta.url);
+import { createRequire as createRequire15 } from "module";
+var _require15 = createRequire15(import.meta.url);
 var MODEL_DIMENSIONS2 = {
   "text-embedding-004": 768,
   "embedding-001": 768
@@ -3242,7 +3545,7 @@ var GoogleEmbedding = class {
     this.model = config.model ?? "text-embedding-004";
     this.dimensions = config.dimensions ?? MODEL_DIMENSIONS2[this.model] ?? 768;
     try {
-      const { GoogleGenAI } = _require14("@google/genai");
+      const { GoogleGenAI } = _require15("@google/genai");
       this.ai = new GoogleGenAI({
         apiKey: config.apiKey ?? process.env.GOOGLE_API_KEY
       });
@@ -3422,7 +3725,391 @@ ${summaries.join("\n")}`;
     await this.storage.delete(SHORT_TERM_NS, sessionId);
   }
 };
+
+// src/mcp/mcp-client.ts
+var MCPToolProvider = class {
+  name;
+  config;
+  client = null;
+  transportInstance = null;
+  tools = [];
+  connected = false;
+  constructor(config) {
+    this.name = config.name;
+    this.config = config;
+  }
+  async connect() {
+    if (this.connected) return;
+    let ClientClass;
+    try {
+      const mod = await import("@modelcontextprotocol/sdk/client/index.js");
+      ClientClass = mod.Client;
+    } catch {
+      throw new Error(
+        "@modelcontextprotocol/sdk is required for MCPToolProvider. Install it: npm install @modelcontextprotocol/sdk"
+      );
+    }
+    this.client = new ClientClass(
+      { name: `radaros-${this.name}`, version: "1.0.0" },
+      { capabilities: {} }
+    );
+    if (this.config.transport === "stdio") {
+      if (!this.config.command) {
+        throw new Error("MCPToolProvider: 'command' is required for stdio transport");
+      }
+      const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+      this.transportInstance = new StdioClientTransport({
+        command: this.config.command,
+        args: this.config.args ?? [],
+        env: { ...process.env, ...this.config.env ?? {} }
+      });
+    } else if (this.config.transport === "http") {
+      if (!this.config.url) {
+        throw new Error("MCPToolProvider: 'url' is required for http transport");
+      }
+      let TransportClass;
+      try {
+        const mod = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+        TransportClass = mod.StreamableHTTPClientTransport;
+      } catch {
+        const mod = await import("@modelcontextprotocol/sdk/client/sse.js");
+        TransportClass = mod.SSEClientTransport;
+      }
+      this.transportInstance = new TransportClass(
+        new URL(this.config.url),
+        { requestInit: { headers: this.config.headers ?? {} } }
+      );
+    } else {
+      throw new Error(`MCPToolProvider: unsupported transport '${this.config.transport}'`);
+    }
+    await this.client.connect(this.transportInstance);
+    this.connected = true;
+    await this.discoverTools();
+  }
+  async discoverTools() {
+    const { z: z3 } = await import("zod");
+    const result = await this.client.listTools();
+    const mcpTools = result.tools ?? [];
+    this.tools = mcpTools.map((mcpTool) => {
+      const toolName = mcpTool.name;
+      const description = mcpTool.description ?? "";
+      const inputSchema = mcpTool.inputSchema ?? { type: "object", properties: {} };
+      const parameters = this.jsonSchemaToZod(inputSchema, z3);
+      const execute = async (args, _ctx) => {
+        const callResult = await this.client.callTool({
+          name: toolName,
+          arguments: args
+        });
+        const contents = callResult.content ?? [];
+        const textParts = contents.filter((c) => c.type === "text").map((c) => c.text);
+        const text = textParts.join("\n") || JSON.stringify(callResult);
+        const artifacts = contents.filter((c) => c.type !== "text").map((c) => ({
+          type: c.type,
+          data: c.data ?? c.blob ?? c.text,
+          mimeType: c.mimeType
+        }));
+        if (artifacts.length > 0) {
+          return { content: text, artifacts };
+        }
+        return text;
+      };
+      return {
+        name: `${this.name}__${toolName}`,
+        description: `[${this.name}] ${description}`,
+        parameters,
+        execute,
+        rawJsonSchema: inputSchema
+      };
+    });
+  }
+  jsonSchemaToZod(schema, z3) {
+    if (!schema || !schema.properties) {
+      return z3.object({}).passthrough();
+    }
+    const shape = {};
+    const required = schema.required ?? [];
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      let field;
+      switch (prop.type) {
+        case "string":
+          field = z3.string();
+          if (prop.enum) field = z3.enum(prop.enum);
+          break;
+        case "number":
+        case "integer":
+          field = z3.number();
+          break;
+        case "boolean":
+          field = z3.boolean();
+          break;
+        case "array":
+          field = z3.array(z3.any());
+          break;
+        case "object":
+          field = z3.record(z3.any());
+          break;
+        default:
+          field = z3.any();
+      }
+      if (prop.description) {
+        field = field.describe(prop.description);
+      }
+      if (!required.includes(key)) {
+        field = field.optional();
+      }
+      shape[key] = field;
+    }
+    return z3.object(shape);
+  }
+  /**
+   * Returns tools from this MCP server as RadarOS ToolDef[].
+   * Optionally filter by tool names to reduce token usage.
+   *
+   * @param filter - Tool names to include (without the server name prefix).
+   *                 If omitted, returns all tools.
+   *
+   * @example
+   * // All tools
+   * await mcp.getTools()
+   *
+   * // Only specific tools (pass the original MCP tool names, not prefixed)
+   * await mcp.getTools({ include: ["get_latest_release", "search_repositories"] })
+   *
+   * // Exclude specific tools
+   * await mcp.getTools({ exclude: ["push_files", "create_repository"] })
+   */
+  async getTools(filter) {
+    if (!this.connected) {
+      await this.connect();
+    }
+    if (!filter) {
+      return [...this.tools];
+    }
+    const prefix = `${this.name}__`;
+    return this.tools.filter((tool) => {
+      const shortName = tool.name.startsWith(prefix) ? tool.name.slice(prefix.length) : tool.name;
+      if (filter.include) {
+        return filter.include.includes(shortName);
+      }
+      if (filter.exclude) {
+        return !filter.exclude.includes(shortName);
+      }
+      return true;
+    });
+  }
+  /** Refresh the tool list from the MCP server. */
+  async refresh() {
+    if (!this.connected) {
+      throw new Error("MCPToolProvider: not connected. Call connect() first.");
+    }
+    await this.discoverTools();
+  }
+  /** Disconnect from the MCP server. */
+  async close() {
+    if (this.client && this.connected) {
+      try {
+        await this.client.close();
+      } catch {
+      }
+      this.connected = false;
+      this.tools = [];
+    }
+  }
+};
+
+// src/a2a/a2a-remote-agent.ts
+import { z as z2 } from "zod";
+var A2ARemoteAgent = class {
+  url;
+  name;
+  instructions;
+  skills = [];
+  headers;
+  timeoutMs;
+  card = null;
+  rpcId = 0;
+  get tools() {
+    return [];
+  }
+  get modelId() {
+    return "a2a-remote";
+  }
+  get providerId() {
+    return "a2a";
+  }
+  get hasStructuredOutput() {
+    return false;
+  }
+  constructor(config) {
+    this.url = config.url.replace(/\/$/, "");
+    this.name = config.name ?? "remote-agent";
+    this.instructions = "";
+    this.headers = config.headers ?? {};
+    this.timeoutMs = config.timeoutMs ?? 6e4;
+  }
+  /**
+   * Fetch the Agent Card from /.well-known/agent.json and populate metadata.
+   */
+  async discover() {
+    const res = await fetch(`${this.url}/.well-known/agent.json`, {
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    if (!res.ok) {
+      throw new Error(
+        `A2A discover failed: ${res.status} ${res.statusText} from ${this.url}`
+      );
+    }
+    this.card = await res.json();
+    this.name = this.card.name;
+    this.instructions = this.card.description ?? "";
+    this.skills = this.card.skills?.map((s) => ({
+      id: s.id,
+      name: s.name,
+      description: s.description
+    })) ?? [];
+    return this.card;
+  }
+  /**
+   * Synchronous run: sends message/send and returns RunOutput.
+   */
+  async run(input, opts) {
+    const message = {
+      role: "user",
+      parts: [{ kind: "text", text: input }]
+    };
+    const rpcReq = {
+      jsonrpc: "2.0",
+      id: ++this.rpcId,
+      method: "message/send",
+      params: {
+        message,
+        ...opts?.sessionId ? { sessionId: opts.sessionId } : {}
+      }
+    };
+    const startMs = Date.now();
+    const res = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      body: JSON.stringify(rpcReq),
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    if (!res.ok) {
+      throw new Error(`A2A message/send failed: ${res.status} ${res.statusText}`);
+    }
+    const rpcRes = await res.json();
+    if (rpcRes.error) {
+      throw new Error(`A2A error: ${rpcRes.error.message}`);
+    }
+    const task = rpcRes.result;
+    const agentMsg = task.status?.message;
+    const text = agentMsg ? this.partsToText(agentMsg.parts) : "";
+    return {
+      text,
+      toolCalls: [],
+      usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+      durationMs: Date.now() - startMs
+    };
+  }
+  /**
+   * Streaming run: sends message/stream and yields StreamChunks from SSE.
+   */
+  async *stream(input, opts) {
+    const message = {
+      role: "user",
+      parts: [{ kind: "text", text: input }]
+    };
+    const rpcReq = {
+      jsonrpc: "2.0",
+      id: ++this.rpcId,
+      method: "message/stream",
+      params: {
+        message,
+        ...opts?.sessionId ? { sessionId: opts.sessionId } : {}
+      }
+    };
+    const res = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      body: JSON.stringify(rpcReq),
+      signal: AbortSignal.timeout(this.timeoutMs)
+    });
+    if (!res.ok) {
+      throw new Error(`A2A message/stream failed: ${res.status} ${res.statusText}`);
+    }
+    if (!res.body) {
+      throw new Error("A2A message/stream: no response body for SSE");
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop();
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const jsonStr = line.slice(6).trim();
+        if (!jsonStr) continue;
+        try {
+          const event = JSON.parse(jsonStr);
+          const task = event.result;
+          if (!task) continue;
+          if (task.status?.state === "working" && task.status.message?.parts?.length) {
+            for (const part of task.status.message.parts) {
+              if (part.kind === "text") {
+                yield { type: "text", text: part.text };
+              }
+            }
+          }
+          if (task.status?.state === "completed") {
+            yield {
+              type: "finish",
+              finishReason: "stop",
+              usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+            };
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * Wrap this remote agent as a ToolDef so it can be used by an orchestrator agent.
+   */
+  asTool() {
+    const self = this;
+    return {
+      name: `a2a_${this.name.replace(/[^a-zA-Z0-9_]/g, "_")}`,
+      description: this.instructions || `Remote A2A agent: ${this.name}`,
+      parameters: z2.object({
+        message: z2.string().describe("The message to send to the remote agent")
+      }),
+      async execute(args, _ctx) {
+        const result = await self.run(args.message);
+        return result.text;
+      }
+    };
+  }
+  getAgentCard() {
+    return this.card;
+  }
+  partsToText(parts) {
+    return parts.filter(
+      (p) => p.kind === "text"
+    ).map((p) => p.text).join("\n");
+  }
+};
 export {
+  A2ARemoteAgent,
   Agent,
   AnthropicProvider,
   BaseVectorStore,
@@ -3434,6 +4121,7 @@ export {
   KnowledgeBase,
   LLMLoop,
   Logger,
+  MCPToolProvider,
   Memory,
   ModelRegistry,
   MongoDBStorage,
@@ -3450,6 +4138,7 @@ export {
   Team,
   TeamMode,
   ToolExecutor,
+  VertexAIProvider,
   Workflow,
   anthropic,
   defineTool,
@@ -3458,5 +4147,6 @@ export {
   isMultiModal,
   ollama,
   openai,
-  registry
+  registry,
+  vertex
 };