@radaros/core 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -138,6 +138,8 @@ interface ToolDef {
     description: string;
     parameters: z.ZodObject<any>;
     execute: (args: Record<string, unknown>, ctx: RunContext) => Promise<string | ToolResult>;
+    /** Raw JSON Schema to send to the LLM, bypassing Zod-to-JSON conversion (used by MCP tools). */
+    rawJsonSchema?: Record<string, unknown>;
 }
 interface ToolCallResult {
     toolCallId: string;
@@ -884,4 +886,225 @@ declare class SessionManager {
     deleteSession(sessionId: string): Promise<void>;
 }
 
-export { Agent, type AgentConfig, type AgentEventMap, type AgentHooks, type AgentStep, AnthropicProvider, type Artifact, type AudioPart, BaseVectorStore, type ChatMessage, type ConditionStep, type ContentPart, type EmbeddingProvider, EventBus, type FilePart, type FunctionStep, GoogleEmbedding, type GoogleEmbeddingConfig, GoogleProvider, type GuardrailResult, type ImagePart, InMemoryStorage, InMemoryVectorStore, type InputGuardrail, KnowledgeBase, type KnowledgeBaseConfig, type KnowledgeBaseToolConfig, LLMLoop, type LogLevel, Logger, type LoggerConfig, Memory, type MemoryConfig, type MemoryEntry, type MessageContent, type MessageRole, type ModelConfig, type ModelProvider, ModelRegistry, type ModelResponse, MongoDBStorage, type MongoDBVectorConfig, MongoDBVectorStore, OllamaProvider, OpenAIEmbedding, type OpenAIEmbeddingConfig, OpenAIProvider, type OutputGuardrail, type ParallelStep, type PgVectorConfig, PgVectorStore, PostgresStorage, type QdrantConfig, QdrantVectorStore, RunContext, type RunOpts, type RunOutput, type Session, SessionManager, SqliteStorage, type StepDef, type StepResult, type StorageDriver, type StreamChunk, Team, type TeamConfig, TeamMode, type TextPart, type TokenUsage, type ToolCall, type ToolCallResult, type ToolDef, type ToolDefinition, ToolExecutor, type ToolResult, type VectorDocument, type VectorSearchOptions, type VectorSearchResult, type VectorStore, Workflow, type WorkflowConfig, type WorkflowResult, anthropic, defineTool, getTextContent, google, isMultiModal, ollama, openai, registry };
+interface MCPToolProviderConfig {
+    name: string;
+    transport: "stdio" | "http";
+    /** For stdio transport: command to spawn */
+    command?: string;
+    /** For stdio transport: args for the command */
+    args?: string[];
+    /** For stdio transport: environment variables */
+    env?: Record<string, string>;
+    /** For http transport: server URL */
+    url?: string;
+    /** For http transport: custom headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Connects to an MCP (Model Context Protocol) server and exposes its tools
+ * as native RadarOS ToolDef[] that any Agent can use.
+ *
+ * Supports stdio and HTTP (Streamable HTTP) transports.
+ * Requires: npm install @modelcontextprotocol/sdk
+ */
+declare class MCPToolProvider {
+    readonly name: string;
+    private config;
+    private client;
+    private transportInstance;
+    private tools;
+    private connected;
+    constructor(config: MCPToolProviderConfig);
+    connect(): Promise<void>;
+    private discoverTools;
+    private jsonSchemaToZod;
+    /**
+     * 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"] })
+     */
+    getTools(filter?: {
+        include?: string[];
+        exclude?: string[];
+    }): Promise<ToolDef[]>;
+    /** Refresh the tool list from the MCP server. */
+    refresh(): Promise<void>;
+    /** Disconnect from the MCP server. */
+    close(): Promise<void>;
+}
+
+/**
+ * A2A (Agent-to-Agent) Protocol types.
+ * Based on the A2A specification v0.2.
+ * https://google.github.io/A2A/specification/
+ */
+interface A2ATextPart {
+    kind: "text";
+    text: string;
+}
+interface A2AFilePart {
+    kind: "file";
+    file: {
+        name?: string;
+        mimeType?: string;
+        bytes?: string;
+        uri?: string;
+    };
+}
+interface A2ADataPart {
+    kind: "data";
+    data: Record<string, unknown>;
+}
+type A2APart = A2ATextPart | A2AFilePart | A2ADataPart;
+interface A2AMessage {
+    role: "user" | "agent";
+    parts: A2APart[];
+    messageId?: string;
+    taskId?: string;
+    referenceTaskIds?: string[];
+    metadata?: Record<string, unknown>;
+}
+type A2ATaskState = "submitted" | "working" | "input-required" | "completed" | "failed" | "canceled";
+interface A2AArtifact {
+    artifactId: string;
+    name?: string;
+    description?: string;
+    parts: A2APart[];
+    metadata?: Record<string, unknown>;
+}
+interface A2ATask {
+    id: string;
+    sessionId?: string;
+    status: {
+        state: A2ATaskState;
+        message?: A2AMessage;
+        timestamp?: string;
+    };
+    artifacts?: A2AArtifact[];
+    history?: A2AMessage[];
+    metadata?: Record<string, unknown>;
+}
+interface A2ASkill {
+    id: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+    examples?: string[];
+}
+interface A2AAgentCard {
+    name: string;
+    description?: string;
+    url: string;
+    version?: string;
+    provider?: {
+        organization: string;
+        url?: string;
+    };
+    capabilities?: {
+        streaming?: boolean;
+        pushNotifications?: boolean;
+        stateTransitionHistory?: boolean;
+    };
+    authentication?: {
+        schemes?: string[];
+        credentials?: string;
+    };
+    skills?: A2ASkill[];
+    defaultInputModes?: string[];
+    defaultOutputModes?: string[];
+    supportedInputModes?: string[];
+    supportedOutputModes?: string[];
+}
+interface A2AJsonRpcRequest {
+    jsonrpc: "2.0";
+    id: string | number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface A2AJsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface A2ASendParams {
+    message: A2AMessage;
+    configuration?: {
+        acceptedOutputModes?: string[];
+        blocking?: boolean;
+    };
+    metadata?: Record<string, unknown>;
+}
+interface A2ATaskQueryParams {
+    id: string;
+    historyLength?: number;
+}
+
+interface A2ARemoteAgentConfig {
+    url: string;
+    /** Custom headers for every request (e.g. auth tokens). */
+    headers?: Record<string, string>;
+    /** Override the discovered name. */
+    name?: string;
+    /** Request timeout in ms (default 60000). */
+    timeoutMs?: number;
+}
+/**
+ * A2ARemoteAgent wraps a remote A2A-compliant agent.
+ * It can be used as a tool, a Team member, or called directly.
+ */
+declare class A2ARemoteAgent {
+    readonly url: string;
+    name: string;
+    instructions: string;
+    skills: Array<{
+        id: string;
+        name: string;
+        description?: string;
+    }>;
+    private headers;
+    private timeoutMs;
+    private card;
+    private rpcId;
+    get tools(): ToolDef[];
+    get modelId(): string;
+    get providerId(): string;
+    get hasStructuredOutput(): boolean;
+    constructor(config: A2ARemoteAgentConfig);
+    /**
+     * Fetch the Agent Card from /.well-known/agent.json and populate metadata.
+     */
+    discover(): Promise<A2AAgentCard>;
+    /**
+     * Synchronous run: sends message/send and returns RunOutput.
+     */
+    run(input: string, opts?: RunOpts): Promise<RunOutput>;
+    /**
+     * Streaming run: sends message/stream and yields StreamChunks from SSE.
+     */
+    stream(input: string, opts?: RunOpts): AsyncGenerator<StreamChunk>;
+    /**
+     * Wrap this remote agent as a ToolDef so it can be used by an orchestrator agent.
+     */
+    asTool(): ToolDef;
+    getAgentCard(): A2AAgentCard | null;
+    private partsToText;
+}
+
+export { type A2AAgentCard, type A2AArtifact, type A2ADataPart, type A2AFilePart, type A2AJsonRpcRequest, type A2AJsonRpcResponse, type A2AMessage, type A2APart, A2ARemoteAgent, type A2ARemoteAgentConfig, type A2ASendParams, type A2ASkill, type A2ATask, type A2ATaskQueryParams, type A2ATaskState, type A2ATextPart, Agent, type AgentConfig, type AgentEventMap, type AgentHooks, type AgentStep, AnthropicProvider, type Artifact, type AudioPart, BaseVectorStore, type ChatMessage, type ConditionStep, type ContentPart, type EmbeddingProvider, EventBus, type FilePart, type FunctionStep, GoogleEmbedding, type GoogleEmbeddingConfig, GoogleProvider, type GuardrailResult, type ImagePart, InMemoryStorage, InMemoryVectorStore, type InputGuardrail, KnowledgeBase, type KnowledgeBaseConfig, type KnowledgeBaseToolConfig, LLMLoop, type LogLevel, Logger, type LoggerConfig, MCPToolProvider, type MCPToolProviderConfig, Memory, type MemoryConfig, type MemoryEntry, type MessageContent, type MessageRole, type ModelConfig, type ModelProvider, ModelRegistry, type ModelResponse, MongoDBStorage, type MongoDBVectorConfig, MongoDBVectorStore, OllamaProvider, OpenAIEmbedding, type OpenAIEmbeddingConfig, OpenAIProvider, type OutputGuardrail, type ParallelStep, type PgVectorConfig, PgVectorStore, PostgresStorage, type QdrantConfig, QdrantVectorStore, RunContext, type RunOpts, type RunOutput, type Session, SessionManager, SqliteStorage, type StepDef, type StepResult, type StorageDriver, type StreamChunk, Team, type TeamConfig, TeamMode, type TextPart, type TokenUsage, type ToolCall, type ToolCallResult, type ToolDef, type ToolDefinition, ToolExecutor, type ToolResult, type VectorDocument, type VectorSearchOptions, type VectorSearchResult, type VectorStore, Workflow, type WorkflowConfig, type WorkflowResult, anthropic, defineTool, getTextContent, google, isMultiModal, ollama, openai, registry };

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;
   }
@@ -3422,7 +3430,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 +3826,7 @@ export {
   KnowledgeBase,
   LLMLoop,
   Logger,
+  MCPToolProvider,
   Memory,
   ModelRegistry,
   MongoDBStorage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radaros/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,7 +33,8 @@
     "mongodb": "^6.0.0",
     "ollama": "^0.5.0",
     "openai": "^4.0.0 || ^5.0.0 || ^6.0.0",
-    "pg": "^8.0.0"
+    "pg": "^8.0.0",
+    "@modelcontextprotocol/sdk": ">=1.0.0"
   },
   "peerDependenciesMeta": {
     "openai": {
@@ -59,6 +60,9 @@
     },
     "@qdrant/js-client-rest": {
       "optional": true
+    },
+    "@modelcontextprotocol/sdk": {
+      "optional": true
     }
   }
 }