@radaros/core 0.1.0 → 0.3.0

package/src/mcp/mcp-client.ts

@@ -0,0 +1,264 @@
+import type { ToolDef, ToolResult } from "../tools/types.js";
+import type { RunContext } from "../agent/run-context.js";
+
+export 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
+ */
+export class MCPToolProvider {
+  readonly name: string;
+  private config: MCPToolProviderConfig;
+  private client: any = null;
+  private transportInstance: any = null;
+  private tools: ToolDef[] = [];
+  private connected = false;
+
+  constructor(config: MCPToolProviderConfig) {
+    this.name = config.name;
+    this.config = config;
+  }
+
+  async connect(): Promise<void> {
+    if (this.connected) return;
+
+    let ClientClass: any;
+    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 ?? {}) } as Record<string, string>,
+      });
+    } else if (this.config.transport === "http") {
+      if (!this.config.url) {
+        throw new Error("MCPToolProvider: 'url' is required for http transport");
+      }
+
+      let TransportClass: any;
+      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();
+  }
+
+  private async discoverTools(): Promise<void> {
+    const { z } = await import("zod");
+    const result = await this.client.listTools();
+    const mcpTools: any[] = result.tools ?? [];
+
+    this.tools = mcpTools.map((mcpTool: any) => {
+      const toolName = mcpTool.name;
+      const description = mcpTool.description ?? "";
+      const inputSchema = mcpTool.inputSchema ?? { type: "object", properties: {} };
+
+      const parameters = this.jsonSchemaToZod(inputSchema, z);
+
+      const execute = async (
+        args: Record<string, unknown>,
+        _ctx: RunContext
+      ): Promise<string | ToolResult> => {
+        const callResult = await this.client.callTool({
+          name: toolName,
+          arguments: args,
+        });
+
+        const contents: any[] = callResult.content ?? [];
+        const textParts = contents
+          .filter((c: any) => c.type === "text")
+          .map((c: any) => c.text);
+
+        const text = textParts.join("\n") || JSON.stringify(callResult);
+
+        const artifacts = contents
+          .filter((c: any) => c.type !== "text")
+          .map((c: any) => ({
+            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,
+      } satisfies ToolDef;
+    });
+  }
+
+  private jsonSchemaToZod(schema: any, z: any): any {
+    if (!schema || !schema.properties) {
+      return z.object({}).passthrough();
+    }
+
+    const shape: Record<string, any> = {};
+    const required: string[] = schema.required ?? [];
+
+    for (const [key, prop] of Object.entries(schema.properties) as [string, any][]) {
+      let field: any;
+
+      switch (prop.type) {
+        case "string":
+          field = z.string();
+          if (prop.enum) field = z.enum(prop.enum);
+          break;
+        case "number":
+        case "integer":
+          field = z.number();
+          break;
+        case "boolean":
+          field = z.boolean();
+          break;
+        case "array":
+          field = z.array(z.any());
+          break;
+        case "object":
+          field = z.record(z.any());
+          break;
+        default:
+          field = z.any();
+      }
+
+      if (prop.description) {
+        field = field.describe(prop.description);
+      }
+
+      if (!required.includes(key)) {
+        field = field.optional();
+      }
+
+      shape[key] = field;
+    }
+
+    return z.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?: {
+    include?: string[];
+    exclude?: string[];
+  }): Promise<ToolDef[]> {
+    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(): Promise<void> {
+    if (!this.connected) {
+      throw new Error("MCPToolProvider: not connected. Call connect() first.");
+    }
+    await this.discoverTools();
+  }
+
+  /** Disconnect from the MCP server. */
+  async close(): Promise<void> {
+    if (this.client && this.connected) {
+      try {
+        await this.client.close();
+      } catch {
+        // ignore close errors
+      }
+      this.connected = false;
+      this.tools = [];
+    }
+  }
+}

package/src/models/providers/vertex.ts

@@ -0,0 +1,400 @@
+import { createRequire } from "node:module";
+import type { ModelProvider } from "../provider.js";
+import {
+  getTextContent,
+  isMultiModal,
+  type ChatMessage,
+  type ContentPart,
+  type ModelConfig,
+  type ModelResponse,
+  type StreamChunk,
+  type ToolDefinition,
+  type TokenUsage,
+  type ToolCall,
+} from "../types.js";
+
+const _require = createRequire(import.meta.url);
+
+export interface VertexAIConfig {
+  project?: string;
+  location?: string;
+  /** Service account key JSON string or path (optional — uses ADC by default). */
+  credentials?: string;
+}
+
+/**
+ * Vertex AI provider using Google's @google/genai SDK in Vertex mode.
+ *
+ * Authentication (in order of precedence):
+ *   1. Explicit `project` + `location` in config
+ *   2. GOOGLE_CLOUD_PROJECT / GOOGLE_CLOUD_LOCATION env vars
+ *   3. Application Default Credentials (gcloud auth)
+ */
+export class VertexAIProvider implements ModelProvider {
+  readonly providerId = "vertex";
+  readonly modelId: string;
+  private ai: any = null;
+  private GoogleGenAICtor: any;
+  private project: string;
+  private location: string;
+
+  constructor(modelId: string, config?: VertexAIConfig) {
+    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 } = _require("@google/genai");
+      this.GoogleGenAICtor = GoogleGenAI;
+    } catch {
+      throw new Error(
+        "@google/genai is required for VertexAIProvider. Install it: npm install @google/genai"
+      );
+    }
+  }
+
+  private getClient(): any {
+    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: ChatMessage[],
+    options?: ModelConfig & { tools?: ToolDefinition[] }
+  ): Promise<ModelResponse> {
+    const { systemInstruction, contents } = this.toGoogleMessages(messages);
+
+    const config: Record<string, unknown> = {};
+    if (options?.temperature !== undefined)
+      config.temperature = options.temperature;
+    if (options?.maxTokens !== undefined)
+      config.maxOutputTokens = options.maxTokens;
+    if (options?.topP !== undefined) 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 as Record<string, unknown>
+        );
+      }
+    }
+
+    const params: Record<string, unknown> = {
+      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: ChatMessage[],
+    options?: ModelConfig & { tools?: ToolDefinition[] }
+  ): AsyncGenerator<StreamChunk> {
+    const { systemInstruction, contents } = this.toGoogleMessages(messages);
+
+    const config: Record<string, unknown> = {};
+    if (options?.temperature !== undefined)
+      config.temperature = options.temperature;
+    if (options?.maxTokens !== undefined)
+      config.maxOutputTokens = options.maxTokens;
+    if (options?.topP !== undefined) config.topP = options.topP;
+    if (options?.stop) config.stopSequences = options.stop;
+
+    const params: Record<string, unknown> = {
+      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: any) => 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,
+              }
+            : undefined,
+        };
+      }
+    }
+  }
+
+  // ── Message conversion (identical to GoogleProvider) ─────────────────────
+
+  private toGoogleMessages(messages: ChatMessage[]): {
+    systemInstruction: string | undefined;
+    contents: unknown[];
+  } {
+    let systemInstruction: string | undefined;
+    const contents: unknown[] = [];
+
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        systemInstruction = getTextContent(msg.content) || undefined;
+        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: unknown[] = [];
+        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 };
+  }
+
+  private partToGoogle(part: ContentPart): unknown {
+    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"),
+          },
+        };
+      }
+    }
+  }
+
+  private toGoogleTools(tools: ToolDefinition[]): unknown[] {
+    return tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters,
+    }));
+  }
+
+  private cleanJsonSchema(
+    schema: Record<string, unknown>
+  ): Record<string, unknown> {
+    const cleaned = { ...schema };
+    delete cleaned["$schema"];
+    delete cleaned["$ref"];
+    delete cleaned["additionalProperties"];
+
+    if (cleaned.properties && typeof cleaned.properties === "object") {
+      const props: Record<string, unknown> = {};
+      for (const [key, val] of Object.entries(
+        cleaned.properties as Record<string, unknown>
+      )) {
+        props[key] =
+          typeof val === "object" && val
+            ? this.cleanJsonSchema(val as Record<string, unknown>)
+            : val;
+      }
+      cleaned.properties = props;
+    }
+
+    if (cleaned.items && typeof cleaned.items === "object") {
+      cleaned.items = this.cleanJsonSchema(
+        cleaned.items as Record<string, unknown>
+      );
+    }
+
+    return cleaned;
+  }
+
+  private normalizeResponse(response: any): ModelResponse {
+    const candidate = response.candidates?.[0];
+    const parts = candidate?.content?.parts ?? [];
+
+    let textContent = "";
+    const toolCalls: ToolCall[] = [];
+    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: TokenUsage = {
+      promptTokens: response.usageMetadata?.promptTokenCount ?? 0,
+      completionTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
+      totalTokens: response.usageMetadata?.totalTokenCount ?? 0,
+    };
+
+    let finishReason: ModelResponse["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 : undefined,
+      },
+      usage,
+      finishReason,
+      raw: response,
+    };
+  }
+}

package/src/models/registry.ts

@@ -3,6 +3,7 @@ import { OpenAIProvider } from "./providers/openai.js";
 import { AnthropicProvider } from "./providers/anthropic.js";
 import { GoogleProvider } from "./providers/google.js";
 import { OllamaProvider } from "./providers/ollama.js";
+import { VertexAIProvider } from "./providers/vertex.js";
 
 type ProviderFactory = (
   modelId: string,
@@ -88,3 +89,19 @@ export function ollama(
 ): ModelProvider {
   return registry.resolve("ollama", modelId, config);
 }
+
+registry.register(
+  "vertex",
+  (modelId, config) =>
+    new VertexAIProvider(
+      modelId,
+      config as { project?: string; location?: string; credentials?: string }
+    )
+);
+
+export function vertex(
+  modelId: string,
+  config?: { project?: string; location?: string; credentials?: string }
+): ModelProvider {
+  return registry.resolve("vertex", modelId, config);
+}