@radaros/core 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radaros/core",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -34,7 +34,8 @@
     "ollama": "^0.5.0",
     "openai": "^4.0.0 || ^5.0.0 || ^6.0.0",
     "pg": "^8.0.0",
-    "@modelcontextprotocol/sdk": ">=1.0.0"
+    "@modelcontextprotocol/sdk": ">=1.0.0",
+    "googleapis": ">=100.0.0"
   },
   "peerDependenciesMeta": {
     "openai": {
@@ -63,6 +64,9 @@
     },
     "@modelcontextprotocol/sdk": {
       "optional": true
+    },
+    "googleapis": {
+      "optional": true
     }
   }
 }

package/src/index.ts

@@ -49,11 +49,13 @@ export type {
   ModelConfig,
 } from "./models/types.js";
 export { getTextContent, isMultiModal } from "./models/types.js";
-export { ModelRegistry, registry, openai, anthropic, google, ollama } from "./models/registry.js";
+export { ModelRegistry, registry, openai, anthropic, google, ollama, vertex } from "./models/registry.js";
 export { OpenAIProvider } from "./models/providers/openai.js";
 export { AnthropicProvider } from "./models/providers/anthropic.js";
 export { GoogleProvider } from "./models/providers/google.js";
 export { OllamaProvider } from "./models/providers/ollama.js";
+export { VertexAIProvider } from "./models/providers/vertex.js";
+export type { VertexAIConfig } from "./models/providers/vertex.js";
 
 // Tools
 export { defineTool } from "./tools/define-tool.js";
@@ -133,3 +135,14 @@ export type {
   A2ASendParams,
   A2ATaskQueryParams,
 } from "./a2a/types.js";
+
+// Toolkits
+export { Toolkit } from "./toolkits/base.js";
+export { WebSearchToolkit } from "./toolkits/websearch.js";
+export type { WebSearchConfig } from "./toolkits/websearch.js";
+export { GmailToolkit } from "./toolkits/gmail.js";
+export type { GmailConfig } from "./toolkits/gmail.js";
+export { WhatsAppToolkit } from "./toolkits/whatsapp.js";
+export type { WhatsAppConfig } from "./toolkits/whatsapp.js";
+export { HackerNewsToolkit } from "./toolkits/hackernews.js";
+export type { HackerNewsConfig } from "./toolkits/hackernews.js";

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);
+}

package/src/toolkits/base.ts

@@ -0,0 +1,15 @@
+import type { ToolDef } from "../tools/types.js";
+
+/**
+ * Base class for all RadarOS Toolkits.
+ * A Toolkit is a collection of related tools that share configuration.
+ */
+export abstract class Toolkit {
+  abstract readonly name: string;
+
+  /**
+   * Returns all tools provided by this toolkit as ToolDef[].
+   * Spread them into an Agent's `tools` array.
+   */
+  abstract getTools(): ToolDef[];
+}