@radaros/core 0.3.1 → 0.3.3

package/dist/index.js

@@ -1,4640 +0,0 @@
-// src/agent/agent.ts
-import { v4 as uuidv42 } from "uuid";
-
-// src/events/event-bus.ts
-import { EventEmitter } from "events";
-var EventBus = class {
-  emitter = new EventEmitter();
-  constructor() {
-    this.emitter.setMaxListeners(100);
-  }
-  on(event, handler) {
-    this.emitter.on(event, handler);
-    return this;
-  }
-  once(event, handler) {
-    this.emitter.once(event, handler);
-    return this;
-  }
-  off(event, handler) {
-    this.emitter.off(event, handler);
-    return this;
-  }
-  emit(event, data) {
-    return this.emitter.emit(event, data);
-  }
-  removeAllListeners(event) {
-    this.emitter.removeAllListeners(event);
-    return this;
-  }
-};
-
-// src/storage/in-memory.ts
-var InMemoryStorage = class {
-  store = /* @__PURE__ */ new Map();
-  makeKey(namespace, key) {
-    return `${namespace}:${key}`;
-  }
-  async get(namespace, key) {
-    const raw = this.store.get(this.makeKey(namespace, key));
-    if (raw === void 0) return null;
-    return JSON.parse(raw);
-  }
-  async set(namespace, key, value) {
-    this.store.set(this.makeKey(namespace, key), JSON.stringify(value));
-  }
-  async delete(namespace, key) {
-    this.store.delete(this.makeKey(namespace, key));
-  }
-  async list(namespace, prefix) {
-    const nsPrefix = prefix ? `${namespace}:${prefix}` : `${namespace}:`;
-    const results = [];
-    for (const [fullKey, raw] of this.store.entries()) {
-      if (fullKey.startsWith(nsPrefix)) {
-        const key = fullKey.slice(namespace.length + 1);
-        results.push({ key, value: JSON.parse(raw) });
-      }
-    }
-    return results;
-  }
-  async close() {
-    this.store.clear();
-  }
-};
-
-// src/session/session-manager.ts
-var NAMESPACE = "sessions";
-var SessionManager = class {
-  constructor(storage) {
-    this.storage = storage;
-  }
-  async getOrCreate(sessionId, userId) {
-    const existing = await this.storage.get(NAMESPACE, sessionId);
-    if (existing) return existing;
-    const session = {
-      sessionId,
-      userId,
-      messages: [],
-      state: {},
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    await this.storage.set(NAMESPACE, sessionId, session);
-    return session;
-  }
-  async appendMessage(sessionId, msg) {
-    const session = await this.getOrCreate(sessionId);
-    session.messages.push(msg);
-    session.updatedAt = /* @__PURE__ */ new Date();
-    await this.storage.set(NAMESPACE, sessionId, session);
-  }
-  async appendMessages(sessionId, msgs) {
-    const session = await this.getOrCreate(sessionId);
-    session.messages.push(...msgs);
-    session.updatedAt = /* @__PURE__ */ new Date();
-    await this.storage.set(NAMESPACE, sessionId, session);
-  }
-  async getHistory(sessionId, limit) {
-    const session = await this.storage.get(NAMESPACE, sessionId);
-    if (!session) return [];
-    if (limit && limit > 0) {
-      return session.messages.slice(-limit);
-    }
-    return session.messages;
-  }
-  async updateState(sessionId, patch) {
-    const session = await this.getOrCreate(sessionId);
-    Object.assign(session.state, patch);
-    session.updatedAt = /* @__PURE__ */ new Date();
-    await this.storage.set(NAMESPACE, sessionId, session);
-  }
-  async getState(sessionId) {
-    const session = await this.storage.get(NAMESPACE, sessionId);
-    return session?.state ?? {};
-  }
-  async deleteSession(sessionId) {
-    await this.storage.delete(NAMESPACE, sessionId);
-  }
-};
-
-// src/tools/tool-executor.ts
-import { createRequire } from "module";
-var _require = createRequire(import.meta.url);
-var ToolExecutor = class {
-  tools;
-  concurrency;
-  constructor(tools, concurrency = 5) {
-    this.tools = new Map(tools.map((t) => [t.name, t]));
-    this.concurrency = concurrency;
-  }
-  async executeAll(toolCalls, ctx) {
-    const results = [];
-    for (let i = 0; i < toolCalls.length; i += this.concurrency) {
-      const batch = toolCalls.slice(i, i + this.concurrency);
-      const batchResults = await Promise.allSettled(
-        batch.map((tc) => this.executeSingle(tc, ctx))
-      );
-      for (let j = 0; j < batchResults.length; j++) {
-        const settled = batchResults[j];
-        const tc = batch[j];
-        if (settled.status === "fulfilled") {
-          results.push(settled.value);
-        } else {
-          results.push({
-            toolCallId: tc.id,
-            toolName: tc.name,
-            result: `Error: ${settled.reason?.message ?? "Unknown error"}`,
-            error: settled.reason?.message ?? "Unknown error"
-          });
-        }
-      }
-    }
-    return results;
-  }
-  async executeSingle(toolCall, ctx) {
-    const tool = this.tools.get(toolCall.name);
-    if (!tool) {
-      return {
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        result: `Error: Tool "${toolCall.name}" not found`,
-        error: `Tool "${toolCall.name}" not found`
-      };
-    }
-    ctx.eventBus.emit("tool.call", {
-      runId: ctx.runId,
-      toolName: toolCall.name,
-      args: toolCall.arguments
-    });
-    const parsed = tool.parameters.safeParse(toolCall.arguments);
-    if (!parsed.success) {
-      const errMsg = `Invalid arguments: ${parsed.error.message}`;
-      const result = {
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        result: errMsg,
-        error: errMsg
-      };
-      ctx.eventBus.emit("tool.result", {
-        runId: ctx.runId,
-        toolName: toolCall.name,
-        result: errMsg
-      });
-      return result;
-    }
-    const rawResult = await tool.execute(parsed.data, ctx);
-    const resultContent = typeof rawResult === "string" ? rawResult : rawResult.content;
-    ctx.eventBus.emit("tool.result", {
-      runId: ctx.runId,
-      toolName: toolCall.name,
-      result: resultContent
-    });
-    return {
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      result: rawResult
-    };
-  }
-  getToolDefinitions() {
-    const { zodToJsonSchema } = _require("zod-to-json-schema");
-    const defs = [];
-    for (const tool of this.tools.values()) {
-      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;
-  }
-};
-
-// src/logger/logger.ts
-var LEVEL_ORDER = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  silent: 4
-};
-var C = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  italic: "\x1B[3m",
-  black: "\x1B[30m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  magenta: "\x1B[35m",
-  cyan: "\x1B[36m",
-  white: "\x1B[37m",
-  bgBlack: "\x1B[40m",
-  bgRed: "\x1B[41m",
-  bgGreen: "\x1B[42m",
-  bgYellow: "\x1B[43m",
-  bgBlue: "\x1B[44m",
-  bgMagenta: "\x1B[45m",
-  bgCyan: "\x1B[46m",
-  gray: "\x1B[90m",
-  brightGreen: "\x1B[92m",
-  brightYellow: "\x1B[93m",
-  brightBlue: "\x1B[94m",
-  brightMagenta: "\x1B[95m",
-  brightCyan: "\x1B[96m"
-};
-function noColor(str) {
-  return str.replace(/\x1b\[[0-9;]*m/g, "");
-}
-var Logger = class {
-  level;
-  color;
-  prefix;
-  constructor(config = {}) {
-    this.level = config.level ?? "info";
-    this.color = config.color ?? process.stdout.isTTY !== false;
-    this.prefix = config.prefix ?? "radaros";
-  }
-  c(code, text) {
-    return this.color ? `${code}${text}${C.reset}` : text;
-  }
-  shouldLog(level) {
-    return LEVEL_ORDER[level] >= LEVEL_ORDER[this.level];
-  }
-  tag(level) {
-    switch (level) {
-      case "debug":
-        return this.c(C.gray, "DBG");
-      case "info":
-        return this.c(C.brightCyan, "INF");
-      case "warn":
-        return this.c(C.brightYellow, "WRN");
-      case "error":
-        return this.c(C.red, "ERR");
-      default:
-        return "";
-    }
-  }
-  timestamp() {
-    const now = /* @__PURE__ */ new Date();
-    const ts = now.toISOString().slice(11, 23);
-    return this.c(C.dim, ts);
-  }
-  log(level, msg, data) {
-    if (!this.shouldLog(level)) return;
-    const parts = [
-      this.timestamp(),
-      this.tag(level),
-      this.c(C.dim, `[${this.prefix}]`),
-      msg
-    ];
-    if (data && Object.keys(data).length > 0) {
-      const formatted = Object.entries(data).map(([k, v]) => `${this.c(C.dim, k + "=")}${this.formatValue(v)}`).join(" ");
-      parts.push(formatted);
-    }
-    console.log(parts.join(" "));
-  }
-  formatValue(v) {
-    if (typeof v === "number") return this.c(C.brightGreen, String(v));
-    if (typeof v === "string") return this.c(C.yellow, `"${v}"`);
-    if (typeof v === "boolean") return this.c(C.magenta, String(v));
-    return String(v);
-  }
-  debug(msg, data) {
-    this.log("debug", msg, data);
-  }
-  info(msg, data) {
-    this.log("info", msg, data);
-  }
-  warn(msg, data) {
-    this.log("warn", msg, data);
-  }
-  error(msg, data) {
-    this.log("error", msg, data);
-  }
-  // ── Formatted agent output helpers ────────────────────────────────────
-  boxWidth = 80;
-  pipe() {
-    return this.c(C.brightCyan, "\u2502");
-  }
-  printBoxLine(label, value, labelColor = C.dim, valueColor = C.white) {
-    const lines = value.split("\n");
-    const prefix = `${this.pipe()} ${this.c(labelColor, label)}`;
-    console.log(`${prefix}${this.c(valueColor, lines[0])}`);
-    const pad = " ".repeat(noColor(label).length);
-    for (let i = 1; i < lines.length; i++) {
-      console.log(`${this.pipe()} ${pad}${this.c(valueColor, lines[i])}`);
-    }
-  }
-  agentStart(agentName, input) {
-    if (!this.shouldLog("info")) return;
-    const title = ` Agent: ${agentName} `;
-    const lineLen = Math.max(0, this.boxWidth - title.length - 2);
-    console.log("");
-    console.log(
-      this.c(C.bold + C.brightCyan, "\u250C\u2500") + this.c(C.bold + C.brightCyan, title) + this.c(C.dim, "\u2500".repeat(lineLen))
-    );
-    this.printBoxLine("Input:  ", input);
-    console.log(this.pipe());
-  }
-  toolCall(toolName, args) {
-    if (!this.shouldLog("debug")) return;
-    const argsStr = JSON.stringify(args, null, 2);
-    console.log(
-      `${this.pipe()} ${this.c(C.brightMagenta, "\u26A1")} ${this.c(C.magenta, toolName)}`
-    );
-    if (argsStr !== "{}" && argsStr !== "[]") {
-      const truncated = argsStr.length > 200 ? argsStr.slice(0, 200) + "\u2026" : argsStr;
-      for (const line of truncated.split("\n")) {
-        console.log(`${this.pipe()}   ${this.c(C.dim, line)}`);
-      }
-    }
-  }
-  toolResult(toolName, result) {
-    if (!this.shouldLog("debug")) return;
-    const truncated = result.length > 300 ? result.slice(0, 300) + "\u2026" : result;
-    console.log(
-      `${this.pipe()} ${this.c(C.green, "\u2713")} ${this.c(C.dim, toolName + " \u2192")}`
-    );
-    for (const line of truncated.split("\n")) {
-      console.log(`${this.pipe()}   ${this.c(C.gray, line)}`);
-    }
-    console.log(this.pipe());
-  }
-  agentEnd(agentName, output, usage, durationMs) {
-    if (!this.shouldLog("info")) return;
-    console.log(this.pipe());
-    this.printBoxLine("Output: ", output);
-    console.log(this.pipe());
-    const tokensLine = this.c(C.dim, "Tokens: ") + this.c(C.brightGreen, `\u2191 ${usage.promptTokens}`) + this.c(C.dim, "  ") + this.c(C.brightGreen, `\u2193 ${usage.completionTokens}`) + this.c(C.dim, "  ") + this.c(C.bold + C.brightGreen, `\u03A3 ${usage.totalTokens}`);
-    const duration = this.c(C.dim, "Duration: ") + this.c(C.yellow, this.formatDuration(durationMs));
-    console.log(`${this.pipe()} ${tokensLine}`);
-    console.log(`${this.pipe()} ${duration}`);
-    console.log(
-      this.c(C.bold + C.brightCyan, "\u2514") + this.c(C.dim, "\u2500".repeat(this.boxWidth - 1))
-    );
-  }
-  separator() {
-    if (!this.shouldLog("info")) return;
-    console.log(this.c(C.dim, "\u2500".repeat(this.boxWidth)));
-  }
-  formatDuration(ms) {
-    if (ms < 1e3) return `${ms}ms`;
-    const secs = (ms / 1e3).toFixed(1);
-    return `${secs}s`;
-  }
-};
-
-// src/agent/llm-loop.ts
-import { createRequire as createRequire2 } from "module";
-
-// src/models/types.ts
-function getTextContent(content) {
-  if (content === null) return "";
-  if (typeof content === "string") return content;
-  return content.filter((p) => p.type === "text").map((p) => p.text).join("");
-}
-function isMultiModal(content) {
-  return Array.isArray(content);
-}
-
-// src/agent/llm-loop.ts
-var _require2 = createRequire2(import.meta.url);
-var LLMLoop = class {
-  provider;
-  toolExecutor;
-  maxToolRoundtrips;
-  temperature;
-  maxTokens;
-  structuredOutput;
-  logger;
-  constructor(provider, toolExecutor, options) {
-    this.provider = provider;
-    this.toolExecutor = toolExecutor;
-    this.maxToolRoundtrips = options.maxToolRoundtrips;
-    this.temperature = options.temperature;
-    this.maxTokens = options.maxTokens;
-    this.structuredOutput = options.structuredOutput;
-    this.logger = options.logger;
-  }
-  async run(messages, ctx, apiKey) {
-    const allToolCalls = [];
-    let totalPromptTokens = 0;
-    let totalCompletionTokens = 0;
-    const currentMessages = [...messages];
-    const toolDefs = this.toolExecutor?.getToolDefinitions() ?? [];
-    for (let roundtrip = 0; roundtrip <= this.maxToolRoundtrips; roundtrip++) {
-      const modelConfig = {};
-      if (apiKey) modelConfig.apiKey = apiKey;
-      if (this.temperature !== void 0)
-        modelConfig.temperature = this.temperature;
-      if (this.maxTokens !== void 0) modelConfig.maxTokens = this.maxTokens;
-      if (toolDefs.length > 0) modelConfig.tools = toolDefs;
-      if (this.structuredOutput) {
-        modelConfig.responseFormat = {
-          type: "json_schema",
-          schema: this.zodToJsonSchema(this.structuredOutput),
-          name: "structured_response"
-        };
-      }
-      const response = await this.provider.generate(
-        currentMessages,
-        modelConfig
-      );
-      totalPromptTokens += response.usage.promptTokens;
-      totalCompletionTokens += response.usage.completionTokens;
-      currentMessages.push(response.message);
-      if (response.finishReason !== "tool_calls" || !response.message.toolCalls?.length || !this.toolExecutor) {
-        const text2 = getTextContent(response.message.content);
-        const output = {
-          text: text2,
-          toolCalls: allToolCalls,
-          usage: {
-            promptTokens: totalPromptTokens,
-            completionTokens: totalCompletionTokens,
-            totalTokens: totalPromptTokens + totalCompletionTokens
-          }
-        };
-        if (this.structuredOutput && text2) {
-          try {
-            const jsonStr = this.extractJson(text2);
-            const parsed = JSON.parse(jsonStr);
-            output.structured = this.structuredOutput.parse(parsed);
-          } catch {
-          }
-        }
-        return output;
-      }
-      const toolResults = await this.toolExecutor.executeAll(
-        response.message.toolCalls,
-        ctx
-      );
-      allToolCalls.push(...toolResults);
-      for (const result of toolResults) {
-        const content = typeof result.result === "string" ? result.result : result.result.content;
-        this.logger?.toolCall(result.toolName, {});
-        this.logger?.toolResult(result.toolName, typeof content === "string" ? content : JSON.stringify(content));
-        currentMessages.push({
-          role: "tool",
-          content,
-          toolCallId: result.toolCallId,
-          name: result.toolName
-        });
-      }
-    }
-    const lastAssistantMsg = currentMessages.reverse().find((m) => m.role === "assistant");
-    const text = getTextContent(lastAssistantMsg?.content ?? null);
-    return {
-      text,
-      toolCalls: allToolCalls,
-      usage: {
-        promptTokens: totalPromptTokens,
-        completionTokens: totalCompletionTokens,
-        totalTokens: totalPromptTokens + totalCompletionTokens
-      }
-    };
-  }
-  async *stream(messages, ctx, apiKey) {
-    const currentMessages = [...messages];
-    const toolDefs = this.toolExecutor?.getToolDefinitions() ?? [];
-    for (let roundtrip = 0; roundtrip <= this.maxToolRoundtrips; roundtrip++) {
-      const modelConfig = {};
-      if (apiKey) modelConfig.apiKey = apiKey;
-      if (this.temperature !== void 0)
-        modelConfig.temperature = this.temperature;
-      if (this.maxTokens !== void 0) modelConfig.maxTokens = this.maxTokens;
-      if (toolDefs.length > 0) modelConfig.tools = toolDefs;
-      let fullText = "";
-      const pendingToolCalls = [];
-      let finishReason = "stop";
-      const streamGen = this.provider.stream(currentMessages, modelConfig);
-      for await (const chunk of streamGen) {
-        yield chunk;
-        if (chunk.type === "text") {
-          fullText += chunk.text;
-          ctx.eventBus.emit("run.stream.chunk", {
-            runId: ctx.runId,
-            chunk: chunk.text
-          });
-        } else if (chunk.type === "tool_call_start") {
-          pendingToolCalls.push({
-            id: chunk.toolCall.id,
-            name: chunk.toolCall.name,
-            args: ""
-          });
-        } else if (chunk.type === "tool_call_delta") {
-          const tc = pendingToolCalls.find(
-            (t) => t.id === chunk.toolCallId
-          );
-          if (tc) {
-            tc.args += chunk.argumentsDelta;
-          }
-        } else if (chunk.type === "finish") {
-          finishReason = chunk.finishReason;
-        }
-      }
-      if (finishReason !== "tool_calls" || pendingToolCalls.length === 0 || !this.toolExecutor) {
-        return;
-      }
-      const assistantMsg = {
-        role: "assistant",
-        content: fullText || null,
-        toolCalls: pendingToolCalls.map((tc) => ({
-          id: tc.id,
-          name: tc.name,
-          arguments: JSON.parse(tc.args || "{}")
-        }))
-      };
-      currentMessages.push(assistantMsg);
-      const toolResults = await this.toolExecutor.executeAll(
-        assistantMsg.toolCalls,
-        ctx
-      );
-      for (const result of toolResults) {
-        const content = typeof result.result === "string" ? result.result : result.result.content;
-        currentMessages.push({
-          role: "tool",
-          content,
-          toolCallId: result.toolCallId,
-          name: result.toolName
-        });
-      }
-    }
-  }
-  extractJson(text) {
-    const fenceMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
-    if (fenceMatch) return fenceMatch[1].trim();
-    const braceStart = text.indexOf("{");
-    const braceEnd = text.lastIndexOf("}");
-    if (braceStart !== -1 && braceEnd > braceStart) {
-      return text.slice(braceStart, braceEnd + 1);
-    }
-    return text.trim();
-  }
-  zodToJsonSchema(schema) {
-    try {
-      const { zodToJsonSchema } = _require2("zod-to-json-schema");
-      return zodToJsonSchema(schema, { target: "openApi3" });
-    } catch {
-      return {};
-    }
-  }
-};
-
-// src/agent/run-context.ts
-import { v4 as uuidv4 } from "uuid";
-var RunContext = class {
-  runId;
-  sessionId;
-  userId;
-  metadata;
-  eventBus;
-  sessionState;
-  constructor(opts) {
-    this.runId = opts.runId ?? uuidv4();
-    this.sessionId = opts.sessionId;
-    this.userId = opts.userId;
-    this.metadata = opts.metadata ?? {};
-    this.eventBus = opts.eventBus;
-    this.sessionState = opts.sessionState ?? {};
-  }
-  getState(key) {
-    return this.sessionState[key];
-  }
-  setState(key, value) {
-    this.sessionState[key] = value;
-  }
-};
-
-// src/agent/agent.ts
-var Agent = class {
-  name;
-  eventBus;
-  instructions;
-  config;
-  sessionManager;
-  llmLoop;
-  logger;
-  get tools() {
-    return this.config.tools ?? [];
-  }
-  get modelId() {
-    return this.config.model.modelId;
-  }
-  get providerId() {
-    return this.config.model.providerId;
-  }
-  get hasStructuredOutput() {
-    return !!this.config.structuredOutput;
-  }
-  constructor(config) {
-    this.config = config;
-    this.name = config.name;
-    this.instructions = config.instructions;
-    this.eventBus = config.eventBus ?? new EventBus();
-    const storage = config.storage ?? new InMemoryStorage();
-    this.sessionManager = new SessionManager(storage);
-    this.logger = new Logger({
-      level: config.logLevel ?? "silent",
-      prefix: config.name
-    });
-    const toolExecutor = config.tools && config.tools.length > 0 ? new ToolExecutor(config.tools) : null;
-    this.llmLoop = new LLMLoop(config.model, toolExecutor, {
-      maxToolRoundtrips: config.maxToolRoundtrips ?? 10,
-      temperature: config.temperature,
-      structuredOutput: config.structuredOutput,
-      logger: this.logger
-    });
-  }
-  async run(input, opts) {
-    const startTime = Date.now();
-    const sessionId = opts?.sessionId ?? this.config.sessionId ?? uuidv42();
-    const userId = opts?.userId ?? this.config.userId;
-    const inputText = typeof input === "string" ? input : getTextContent(input);
-    const session = await this.sessionManager.getOrCreate(sessionId, userId);
-    const ctx = new RunContext({
-      sessionId,
-      userId,
-      metadata: opts?.metadata ?? {},
-      eventBus: this.eventBus,
-      sessionState: { ...session.state }
-    });
-    this.logger.agentStart(this.name, inputText);
-    this.eventBus.emit("run.start", {
-      runId: ctx.runId,
-      agentName: this.name,
-      input: inputText
-    });
-    try {
-      if (this.config.hooks?.beforeRun) {
-        await this.config.hooks.beforeRun(ctx);
-      }
-      if (this.config.guardrails?.input) {
-        for (const guardrail of this.config.guardrails.input) {
-          const result = await guardrail.validate(input, ctx);
-          if (!result.pass) {
-            throw new Error(
-              `Input guardrail "${guardrail.name}" blocked: ${result.reason}`
-            );
-          }
-        }
-      }
-      const messages = await this.buildMessages(input, sessionId, ctx);
-      const output = await this.llmLoop.run(messages, ctx, opts?.apiKey);
-      output.durationMs = Date.now() - startTime;
-      if (this.config.guardrails?.output) {
-        for (const guardrail of this.config.guardrails.output) {
-          const result = await guardrail.validate(output, ctx);
-          if (!result.pass) {
-            throw new Error(
-              `Output guardrail "${guardrail.name}" blocked: ${result.reason}`
-            );
-          }
-        }
-      }
-      await this.sessionManager.appendMessages(sessionId, [
-        { role: "user", content: inputText },
-        { role: "assistant", content: output.text }
-      ]);
-      await this.sessionManager.updateState(sessionId, ctx.sessionState);
-      if (this.config.memory) {
-        await this.config.memory.addMessages(sessionId, [
-          { role: "user", content: inputText },
-          { role: "assistant", content: output.text }
-        ]);
-      }
-      if (this.config.hooks?.afterRun) {
-        await this.config.hooks.afterRun(ctx, output);
-      }
-      this.logger.agentEnd(this.name, output.text, output.usage, output.durationMs);
-      this.eventBus.emit("run.complete", {
-        runId: ctx.runId,
-        output
-      });
-      return output;
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.logger.error(`Run failed: ${err.message}`);
-      if (this.config.hooks?.onError) {
-        await this.config.hooks.onError(ctx, err);
-      }
-      this.eventBus.emit("run.error", {
-        runId: ctx.runId,
-        error: err
-      });
-      throw err;
-    }
-  }
-  async *stream(input, opts) {
-    const sessionId = opts?.sessionId ?? this.config.sessionId ?? uuidv42();
-    const userId = opts?.userId ?? this.config.userId;
-    const inputText = typeof input === "string" ? input : getTextContent(input);
-    const session = await this.sessionManager.getOrCreate(sessionId, userId);
-    const ctx = new RunContext({
-      sessionId,
-      userId,
-      metadata: opts?.metadata ?? {},
-      eventBus: this.eventBus,
-      sessionState: { ...session.state }
-    });
-    this.eventBus.emit("run.start", {
-      runId: ctx.runId,
-      agentName: this.name,
-      input: inputText
-    });
-    let fullText = "";
-    let streamOk = false;
-    try {
-      if (this.config.hooks?.beforeRun) {
-        await this.config.hooks.beforeRun(ctx);
-      }
-      if (this.config.guardrails?.input) {
-        for (const guardrail of this.config.guardrails.input) {
-          const result = await guardrail.validate(input, ctx);
-          if (!result.pass) {
-            throw new Error(
-              `Input guardrail "${guardrail.name}" blocked: ${result.reason}`
-            );
-          }
-        }
-      }
-      const messages = await this.buildMessages(input, sessionId, ctx);
-      for await (const chunk of this.llmLoop.stream(messages, ctx, opts?.apiKey)) {
-        if (chunk.type === "text") {
-          fullText += chunk.text;
-        }
-        yield chunk;
-      }
-      streamOk = true;
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      if (this.config.hooks?.onError) {
-        await this.config.hooks.onError(ctx, err);
-      }
-      this.eventBus.emit("run.error", {
-        runId: ctx.runId,
-        error: err
-      });
-      throw err;
-    } finally {
-      if (streamOk) {
-        await this.sessionManager.appendMessages(sessionId, [
-          { role: "user", content: inputText },
-          { role: "assistant", content: fullText }
-        ]);
-        await this.sessionManager.updateState(sessionId, ctx.sessionState);
-        if (this.config.memory) {
-          await this.config.memory.addMessages(sessionId, [
-            { role: "user", content: inputText },
-            { role: "assistant", content: fullText }
-          ]);
-        }
-        this.eventBus.emit("run.complete", {
-          runId: ctx.runId,
-          output: {
-            text: fullText,
-            toolCalls: [],
-            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
-          }
-        });
-      }
-    }
-  }
-  async buildMessages(input, sessionId, ctx) {
-    const messages = [];
-    let systemContent = "";
-    if (this.config.instructions) {
-      systemContent = typeof this.config.instructions === "function" ? this.config.instructions(ctx) : this.config.instructions;
-    }
-    if (this.config.memory) {
-      const memoryContext = await this.config.memory.getContextString(
-        sessionId
-      );
-      if (memoryContext) {
-        systemContent = systemContent ? `${systemContent}
-
-${memoryContext}` : memoryContext;
-      }
-    }
-    if (systemContent) {
-      messages.push({ role: "system", content: systemContent });
-    }
-    if (this.config.addHistoryToMessages !== false) {
-      const limit = this.config.numHistoryRuns ? this.config.numHistoryRuns * 2 : 20;
-      const history = await this.sessionManager.getHistory(sessionId, limit);
-      if (history.length > 0) {
-        this.logger.info(`Loaded ${history.length} history messages for session ${sessionId}`);
-        if (messages.length > 0 && messages[0].role === "system") {
-          messages[0] = {
-            ...messages[0],
-            content: `${getTextContent(messages[0].content)}
-
-This is a multi-turn conversation. The previous messages in this session are included below. Use them to maintain context and answer questions about prior exchanges.`
-          };
-        }
-      }
-      messages.push(...history);
-    }
-    messages.push({ role: "user", content: input });
-    this.logger.info(`Sending ${messages.length} messages to LLM: ${messages.map((m) => `[${m.role}: ${typeof m.content === "string" ? m.content.slice(0, 40) : "(multimodal)"}]`).join(", ")}`);
-    return messages;
-  }
-};
-
-// src/team/team.ts
-import { v4 as uuidv43 } from "uuid";
-
-// src/team/types.ts
-var TeamMode = /* @__PURE__ */ ((TeamMode2) => {
-  TeamMode2["Coordinate"] = "coordinate";
-  TeamMode2["Route"] = "route";
-  TeamMode2["Broadcast"] = "broadcast";
-  TeamMode2["Collaborate"] = "collaborate";
-  return TeamMode2;
-})(TeamMode || {});
-
-// src/team/team.ts
-var Team = class {
-  name;
-  eventBus;
-  config;
-  constructor(config) {
-    this.config = config;
-    this.name = config.name;
-    this.eventBus = config.eventBus ?? new EventBus();
-  }
-  async run(input, opts) {
-    const ctx = new RunContext({
-      sessionId: opts?.sessionId ?? uuidv43(),
-      userId: opts?.userId,
-      metadata: opts?.metadata ?? {},
-      eventBus: this.eventBus,
-      sessionState: { ...this.config.sessionState ?? {} }
-    });
-    this.eventBus.emit("run.start", {
-      runId: ctx.runId,
-      agentName: this.name,
-      input
-    });
-    try {
-      let output;
-      switch (this.config.mode) {
-        case "route" /* Route */:
-          output = await this.runRouteMode(input, ctx);
-          break;
-        case "broadcast" /* Broadcast */:
-          output = await this.runBroadcastMode(input, ctx);
-          break;
-        case "collaborate" /* Collaborate */:
-          output = await this.runCollaborateMode(input, ctx);
-          break;
-        case "coordinate" /* Coordinate */:
-        default:
-          output = await this.runCoordinateMode(input, ctx);
-          break;
-      }
-      this.eventBus.emit("run.complete", { runId: ctx.runId, output });
-      return output;
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.eventBus.emit("run.error", { runId: ctx.runId, error: err });
-      throw err;
-    }
-  }
-  async *stream(input, opts) {
-    const result = await this.run(input, opts);
-    yield { type: "text", text: result.text };
-    yield { type: "finish", finishReason: "stop", usage: result.usage };
-  }
-  async runCoordinateMode(input, ctx) {
-    const memberDescriptions = this.buildMemberDescriptions();
-    const planPrompt = this.buildCoordinatorPrompt(
-      input,
-      memberDescriptions,
-      "coordinate"
-    );
-    const planResponse = await this.config.model.generate([
-      { role: "system", content: planPrompt },
-      { role: "user", content: input }
-    ]);
-    const delegations = this.parseDelegationPlan(
-      getTextContent(planResponse.message.content)
-    );
-    const memberOutputs = [];
-    for (const delegation of delegations) {
-      const member = this.findMember(delegation.memberId);
-      if (!member) continue;
-      this.eventBus.emit("team.delegate", {
-        runId: ctx.runId,
-        memberId: delegation.memberId,
-        task: delegation.task
-      });
-      const output = await member.run(delegation.task, {
-        sessionId: ctx.sessionId
-      });
-      memberOutputs.push({ memberId: delegation.memberId, output });
-    }
-    const synthesisPrompt = this.buildSynthesisPrompt(
-      input,
-      memberOutputs
-    );
-    const synthesisResponse = await this.config.model.generate([
-      { role: "user", content: synthesisPrompt }
-    ]);
-    return {
-      text: getTextContent(synthesisResponse.message.content),
-      toolCalls: memberOutputs.flatMap((o) => o.output.toolCalls),
-      usage: synthesisResponse.usage
-    };
-  }
-  async runRouteMode(input, ctx) {
-    const memberDescriptions = this.buildMemberDescriptions();
-    const routePrompt = this.buildCoordinatorPrompt(
-      input,
-      memberDescriptions,
-      "route"
-    );
-    const routeResponse = await this.config.model.generate([
-      { role: "system", content: routePrompt },
-      { role: "user", content: input }
-    ]);
-    const selectedName = getTextContent(routeResponse.message.content).trim();
-    const member = this.findMember(selectedName);
-    if (!member) {
-      return {
-        text: `Could not route to member "${selectedName}". Available: ${this.config.members.map((m) => m.name).join(", ")}`,
-        toolCalls: [],
-        usage: routeResponse.usage
-      };
-    }
-    this.eventBus.emit("team.delegate", {
-      runId: ctx.runId,
-      memberId: member.name,
-      task: input
-    });
-    return member.run(input, { sessionId: ctx.sessionId });
-  }
-  async runBroadcastMode(input, ctx) {
-    for (const member of this.config.members) {
-      this.eventBus.emit("team.delegate", {
-        runId: ctx.runId,
-        memberId: member.name,
-        task: input
-      });
-    }
-    const outputs = await Promise.all(
-      this.config.members.map(
-        (member) => member.run(input, { sessionId: ctx.sessionId })
-      )
-    );
-    const memberOutputs = this.config.members.map((member, i) => ({
-      memberId: member.name,
-      output: outputs[i]
-    }));
-    const synthesisPrompt = this.buildSynthesisPrompt(input, memberOutputs);
-    const synthesisResponse = await this.config.model.generate([
-      { role: "user", content: synthesisPrompt }
-    ]);
-    return {
-      text: getTextContent(synthesisResponse.message.content),
-      toolCalls: outputs.flatMap((o) => o.toolCalls),
-      usage: synthesisResponse.usage
-    };
-  }
-  async runCollaborateMode(input, ctx) {
-    const maxRounds = this.config.maxRounds ?? 3;
-    let currentInput = input;
-    let finalOutput = null;
-    for (let round = 0; round < maxRounds; round++) {
-      for (const member of this.config.members) {
-        this.eventBus.emit("team.delegate", {
-          runId: ctx.runId,
-          memberId: member.name,
-          task: currentInput
-        });
-      }
-      const outputs = await Promise.all(
-        this.config.members.map(
-          (member) => member.run(currentInput, { sessionId: ctx.sessionId })
-        )
-      );
-      const memberOutputs = this.config.members.map((member, i) => ({
-        memberId: member.name,
-        output: outputs[i]
-      }));
-      const consensusPrompt = `Given the following responses to "${input}", determine if there is consensus. If yes, synthesize a final answer. If not, provide a follow-up question.
-
-${memberOutputs.map((o) => `${o.memberId}: ${o.output.text}`).join("\n\n")}
-
-Respond with either "CONSENSUS: <final answer>" or "FOLLOW_UP: <question>"`;
-      const consensusResponse = await this.config.model.generate([
-        { role: "user", content: consensusPrompt }
-      ]);
-      const responseText = getTextContent(consensusResponse.message.content);
-      if (responseText.startsWith("CONSENSUS:")) {
-        finalOutput = {
-          text: responseText.slice("CONSENSUS:".length).trim(),
-          toolCalls: outputs.flatMap((o) => o.toolCalls),
-          usage: consensusResponse.usage
-        };
-        break;
-      }
-      currentInput = responseText.startsWith("FOLLOW_UP:") ? responseText.slice("FOLLOW_UP:".length).trim() : responseText;
-    }
-    if (!finalOutput) {
-      const lastSynthesis = this.buildSynthesisPrompt(input, []);
-      const response = await this.config.model.generate([
-        { role: "user", content: lastSynthesis }
-      ]);
-      finalOutput = {
-        text: getTextContent(response.message.content),
-        toolCalls: [],
-        usage: response.usage
-      };
-    }
-    return finalOutput;
-  }
-  buildMemberDescriptions() {
-    return this.config.members.map((member) => {
-      const desc = typeof member.instructions === "function" ? "(dynamic instructions)" : member.instructions ?? "General-purpose agent";
-      return `- ${member.name}: ${desc}`;
-    }).join("\n");
-  }
-  buildCoordinatorPrompt(input, memberDescriptions, mode) {
-    if (mode === "route") {
-      return `You are a team coordinator. Based on the user's request, select the single most appropriate team member to handle it. Available members:
-${memberDescriptions}
-
-Respond with ONLY the member name, nothing else.`;
-    }
-    return `You are a team coordinator. Break down the user's request into subtasks and delegate to appropriate team members. Available members:
-${memberDescriptions}
-
-Respond with a JSON array of delegations: [{"memberId": "name", "task": "specific task"}]
-${this.config.instructions ? `
-Additional instructions: ${this.config.instructions}` : ""}`;
-  }
-  buildSynthesisPrompt(originalInput, memberOutputs) {
-    const outputsText = memberOutputs.map((o) => `### ${o.memberId}
-${o.output.text}`).join("\n\n");
-    return `Original request: ${originalInput}
-
-Team member responses:
-${outputsText}
-
-Synthesize these responses into a single coherent answer.`;
-  }
-  parseDelegationPlan(content) {
-    try {
-      const jsonMatch = content.match(/\[[\s\S]*\]/);
-      if (jsonMatch) {
-        return JSON.parse(jsonMatch[0]);
-      }
-    } catch {
-    }
-    return this.config.members.map((m) => ({
-      memberId: m.name,
-      task: content
-    }));
-  }
-  findMember(name) {
-    return this.config.members.find(
-      (m) => m.name.toLowerCase() === name.toLowerCase()
-    );
-  }
-};
-
-// src/workflow/workflow.ts
-import { v4 as uuidv44 } from "uuid";
-
-// src/workflow/step-runner.ts
-function isAgentStep(step) {
-  return "agent" in step;
-}
-function isFunctionStep(step) {
-  return "run" in step;
-}
-function isConditionStep(step) {
-  return "condition" in step;
-}
-function isParallelStep(step) {
-  return "parallel" in step;
-}
-var StepRunner = class {
-  retryPolicy;
-  constructor(retryPolicy) {
-    this.retryPolicy = retryPolicy;
-  }
-  async executeSteps(steps, state, ctx) {
-    let currentState = { ...state };
-    const allResults = [];
-    for (const step of steps) {
-      const { state: newState, results } = await this.executeStep(
-        step,
-        currentState,
-        ctx
-      );
-      currentState = newState;
-      allResults.push(...results);
-    }
-    return { state: currentState, results: allResults };
-  }
-  async executeStep(step, state, ctx) {
-    if (isConditionStep(step)) {
-      return this.executeConditionStep(step, state, ctx);
-    }
-    if (isParallelStep(step)) {
-      return this.executeParallelStep(step, state, ctx);
-    }
-    if (isAgentStep(step)) {
-      return this.executeAgentStep(step, state, ctx);
-    }
-    if (isFunctionStep(step)) {
-      return this.executeFunctionStep(step, state, ctx);
-    }
-    return { state, results: [] };
-  }
-  async executeAgentStep(step, state, ctx) {
-    const startTime = Date.now();
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "start"
-    });
-    const execute = async () => {
-      const input = step.inputFrom ? step.inputFrom(state) : JSON.stringify(state);
-      const output = await step.agent.run(input, {
-        sessionId: ctx.sessionId
-      });
-      const newState = {
-        ...state,
-        [`${step.name}_output`]: output.text
-      };
-      Object.assign(state, newState);
-      return {
-        stepName: step.name,
-        status: "done",
-        durationMs: Date.now() - startTime
-      };
-    };
-    const result = await this.withRetry(step.name, execute, ctx);
-    return { state, results: [result] };
-  }
-  async executeFunctionStep(step, state, ctx) {
-    const startTime = Date.now();
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "start"
-    });
-    const execute = async () => {
-      const patch = await step.run(state, ctx);
-      Object.assign(state, patch);
-      return {
-        stepName: step.name,
-        status: "done",
-        durationMs: Date.now() - startTime
-      };
-    };
-    const result = await this.withRetry(step.name, execute, ctx);
-    return { state, results: [result] };
-  }
-  async executeConditionStep(step, state, ctx) {
-    const startTime = Date.now();
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "start"
-    });
-    if (step.condition(state)) {
-      const { state: newState, results } = await this.executeSteps(
-        step.steps,
-        state,
-        ctx
-      );
-      ctx.eventBus.emit("workflow.step", {
-        runId: ctx.runId,
-        stepName: step.name,
-        status: "done"
-      });
-      return {
-        state: newState,
-        results: [
-          {
-            stepName: step.name,
-            status: "done",
-            durationMs: Date.now() - startTime
-          },
-          ...results
-        ]
-      };
-    }
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "done"
-    });
-    return {
-      state,
-      results: [
-        {
-          stepName: step.name,
-          status: "skipped",
-          durationMs: Date.now() - startTime
-        }
-      ]
-    };
-  }
-  async executeParallelStep(step, state, ctx) {
-    const startTime = Date.now();
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "start"
-    });
-    const settled = await Promise.allSettled(
-      step.parallel.map((s) => this.executeStep(s, { ...state }, ctx))
-    );
-    const allResults = [];
-    let mergedState = { ...state };
-    for (const result of settled) {
-      if (result.status === "fulfilled") {
-        Object.assign(mergedState, result.value.state);
-        allResults.push(...result.value.results);
-      } else {
-        allResults.push({
-          stepName: step.name,
-          status: "error",
-          error: result.reason?.message ?? "Unknown error",
-          durationMs: Date.now() - startTime
-        });
-      }
-    }
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "done"
-    });
-    return {
-      state: mergedState,
-      results: [
-        {
-          stepName: step.name,
-          status: "done",
-          durationMs: Date.now() - startTime
-        },
-        ...allResults
-      ]
-    };
-  }
-  async withRetry(stepName, fn, ctx) {
-    const maxRetries = this.retryPolicy?.maxRetries ?? 0;
-    const backoffMs = this.retryPolicy?.backoffMs ?? 1e3;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        const result = await fn();
-        ctx.eventBus.emit("workflow.step", {
-          runId: ctx.runId,
-          stepName,
-          status: "done"
-        });
-        return result;
-      } catch (error) {
-        if (attempt === maxRetries) {
-          const err = error instanceof Error ? error : new Error(String(error));
-          ctx.eventBus.emit("workflow.step", {
-            runId: ctx.runId,
-            stepName,
-            status: "error"
-          });
-          return {
-            stepName,
-            status: "error",
-            error: err.message,
-            durationMs: 0
-          };
-        }
-        await new Promise(
-          (resolve) => setTimeout(resolve, backoffMs * Math.pow(2, attempt))
-        );
-      }
-    }
-    return { stepName, status: "error", error: "Exhausted retries", durationMs: 0 };
-  }
-};
-
-// src/workflow/workflow.ts
-var Workflow = class {
-  name;
-  eventBus;
-  config;
-  stepRunner;
-  constructor(config) {
-    this.config = config;
-    this.name = config.name;
-    this.eventBus = config.eventBus ?? new EventBus();
-    this.stepRunner = new StepRunner(config.retryPolicy);
-  }
-  async run(opts) {
-    const ctx = new RunContext({
-      sessionId: opts?.sessionId ?? uuidv44(),
-      userId: opts?.userId,
-      eventBus: this.eventBus,
-      sessionState: {}
-    });
-    this.eventBus.emit("run.start", {
-      runId: ctx.runId,
-      agentName: `workflow:${this.name}`,
-      input: JSON.stringify(this.config.initialState)
-    });
-    try {
-      const { state, results } = await this.stepRunner.executeSteps(
-        this.config.steps,
-        { ...this.config.initialState },
-        ctx
-      );
-      const workflowResult = {
-        state,
-        stepResults: results
-      };
-      this.eventBus.emit("run.complete", {
-        runId: ctx.runId,
-        output: {
-          text: JSON.stringify(state),
-          toolCalls: [],
-          usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
-        }
-      });
-      return workflowResult;
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.eventBus.emit("run.error", { runId: ctx.runId, error: err });
-      throw err;
-    }
-  }
-};
-
-// src/models/providers/openai.ts
-import { createRequire as createRequire3 } from "module";
-var _require3 = createRequire3(import.meta.url);
-var OpenAIProvider = class {
-  providerId = "openai";
-  modelId;
-  client;
-  OpenAICtor;
-  baseURL;
-  clientCache = /* @__PURE__ */ new Map();
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    this.baseURL = config?.baseURL;
-    try {
-      const mod = _require3("openai");
-      this.OpenAICtor = mod.default ?? mod;
-      const key = config?.apiKey ?? process.env.OPENAI_API_KEY;
-      if (key) {
-        this.client = new this.OpenAICtor({ apiKey: key, baseURL: config?.baseURL });
-      }
-    } catch {
-      throw new Error(
-        "openai package is required for OpenAIProvider. Install it: npm install openai"
-      );
-    }
-  }
-  getClient(apiKey) {
-    if (apiKey) {
-      let cached = this.clientCache.get(apiKey);
-      if (!cached) {
-        cached = new this.OpenAICtor({ apiKey, baseURL: this.baseURL });
-        this.clientCache.set(apiKey, cached);
-      }
-      return cached;
-    }
-    if (this.client) return this.client;
-    const envKey = process.env.OPENAI_API_KEY;
-    if (envKey) {
-      this.client = new this.OpenAICtor({ apiKey: envKey, baseURL: this.baseURL });
-      return this.client;
-    }
-    throw new Error("No OpenAI API key provided. Pass it via the x-openai-api-key header, apiKey in request body, or set OPENAI_API_KEY env var.");
-  }
-  async generate(messages, options) {
-    const params = {
-      model: this.modelId,
-      messages: this.toOpenAIMessages(messages)
-    };
-    if (options?.temperature !== void 0)
-      params.temperature = options.temperature;
-    if (options?.maxTokens !== void 0)
-      params.max_tokens = options.maxTokens;
-    if (options?.topP !== void 0) params.top_p = options.topP;
-    if (options?.stop) params.stop = options.stop;
-    this.applyResponseFormat(params, options);
-    if (options?.tools?.length) {
-      params.tools = this.toOpenAITools(options.tools);
-    }
-    const client = this.getClient(options?.apiKey);
-    const response = await client.chat.completions.create(params);
-    return this.normalizeResponse(response);
-  }
-  async *stream(messages, options) {
-    const params = {
-      model: this.modelId,
-      messages: this.toOpenAIMessages(messages),
-      stream: true
-    };
-    if (options?.temperature !== void 0)
-      params.temperature = options.temperature;
-    if (options?.maxTokens !== void 0)
-      params.max_tokens = options.maxTokens;
-    if (options?.topP !== void 0) params.top_p = options.topP;
-    if (options?.stop) params.stop = options.stop;
-    this.applyResponseFormat(params, options);
-    if (options?.tools?.length) {
-      params.tools = this.toOpenAITools(options.tools);
-    }
-    const client = this.getClient(options?.apiKey);
-    const stream = await client.chat.completions.create(params);
-    const activeToolCalls = /* @__PURE__ */ new Map();
-    for await (const chunk of stream) {
-      const choice = chunk.choices?.[0];
-      if (!choice) continue;
-      const delta = choice.delta;
-      if (delta?.content) {
-        yield { type: "text", text: delta.content };
-      }
-      if (delta?.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          const idx = tc.index ?? 0;
-          if (tc.id) {
-            activeToolCalls.set(idx, {
-              id: tc.id,
-              name: tc.function?.name ?? "",
-              args: tc.function?.arguments ?? ""
-            });
-            yield {
-              type: "tool_call_start",
-              toolCall: {
-                id: tc.id,
-                name: tc.function?.name ?? ""
-              }
-            };
-          } else if (tc.function?.arguments) {
-            const existing = activeToolCalls.get(idx);
-            if (existing) {
-              existing.args += tc.function.arguments;
-              yield {
-                type: "tool_call_delta",
-                toolCallId: existing.id,
-                argumentsDelta: tc.function.arguments
-              };
-            }
-          }
-          if (tc.function?.name && !tc.id) {
-            const existing = activeToolCalls.get(idx);
-            if (existing) {
-              existing.name = tc.function.name;
-            }
-          }
-        }
-      }
-      if (choice.finish_reason) {
-        for (const [, tc] of activeToolCalls) {
-          yield { type: "tool_call_end", toolCallId: tc.id };
-        }
-        yield {
-          type: "finish",
-          finishReason: choice.finish_reason === "tool_calls" ? "tool_calls" : choice.finish_reason,
-          usage: chunk.usage ? {
-            promptTokens: chunk.usage.prompt_tokens ?? 0,
-            completionTokens: chunk.usage.completion_tokens ?? 0,
-            totalTokens: chunk.usage.total_tokens ?? 0
-          } : void 0
-        };
-      }
-    }
-  }
-  applyResponseFormat(params, options) {
-    if (!options?.responseFormat) return;
-    if (options.responseFormat === "json") {
-      params.response_format = { type: "json_object" };
-    } else if (options.responseFormat === "text") {
-    } else if (typeof options.responseFormat === "object") {
-      params.response_format = {
-        type: "json_schema",
-        json_schema: {
-          name: options.responseFormat.name ?? "response",
-          schema: options.responseFormat.schema,
-          strict: true
-        }
-      };
-    }
-  }
-  toOpenAIMessages(messages) {
-    return messages.map((msg) => {
-      if (msg.role === "assistant" && msg.toolCalls?.length) {
-        return {
-          role: "assistant",
-          content: getTextContent(msg.content),
-          tool_calls: msg.toolCalls.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.arguments)
-            }
-          }))
-        };
-      }
-      if (msg.role === "tool") {
-        return {
-          role: "tool",
-          tool_call_id: msg.toolCallId,
-          content: getTextContent(msg.content)
-        };
-      }
-      if (isMultiModal(msg.content)) {
-        return {
-          role: msg.role,
-          content: msg.content.map((part) => this.partToOpenAI(part))
-        };
-      }
-      return {
-        role: msg.role,
-        content: msg.content ?? ""
-      };
-    });
-  }
-  partToOpenAI(part) {
-    switch (part.type) {
-      case "text":
-        return { type: "text", text: part.text };
-      case "image": {
-        const isUrl = part.data.startsWith("http://") || part.data.startsWith("https://");
-        return {
-          type: "image_url",
-          image_url: {
-            url: isUrl ? part.data : `data:${part.mimeType ?? "image/png"};base64,${part.data}`
-          }
-        };
-      }
-      case "audio":
-        return {
-          type: "input_audio",
-          input_audio: {
-            data: part.data,
-            format: part.mimeType?.split("/")[1] ?? "mp3"
-          }
-        };
-      case "file":
-        return {
-          type: "text",
-          text: `[File: ${part.filename ?? "attachment"} (${part.mimeType})]`
-        };
-    }
-  }
-  toOpenAITools(tools) {
-    return tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters
-      }
-    }));
-  }
-  normalizeResponse(response) {
-    const choice = response.choices[0];
-    const msg = choice.message;
-    const toolCalls = (msg.tool_calls ?? []).map((tc) => ({
-      id: tc.id,
-      name: tc.function.name,
-      arguments: JSON.parse(tc.function.arguments || "{}")
-    }));
-    const usage = {
-      promptTokens: response.usage?.prompt_tokens ?? 0,
-      completionTokens: response.usage?.completion_tokens ?? 0,
-      totalTokens: response.usage?.total_tokens ?? 0
-    };
-    let finishReason = "stop";
-    if (choice.finish_reason === "tool_calls") finishReason = "tool_calls";
-    else if (choice.finish_reason === "length") finishReason = "length";
-    else if (choice.finish_reason === "content_filter")
-      finishReason = "content_filter";
-    return {
-      message: {
-        role: "assistant",
-        content: msg.content ?? null,
-        toolCalls: toolCalls.length > 0 ? toolCalls : void 0
-      },
-      usage,
-      finishReason,
-      raw: response
-    };
-  }
-};
-
-// src/models/providers/anthropic.ts
-import { createRequire as createRequire4 } from "module";
-var _require4 = createRequire4(import.meta.url);
-var AnthropicProvider = class {
-  providerId = "anthropic";
-  modelId;
-  client;
-  AnthropicCtor;
-  clientCache = /* @__PURE__ */ new Map();
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    try {
-      const mod = _require4("@anthropic-ai/sdk");
-      this.AnthropicCtor = mod.default ?? mod;
-      const key = config?.apiKey ?? process.env.ANTHROPIC_API_KEY;
-      if (key) {
-        this.client = new this.AnthropicCtor({ apiKey: key });
-      }
-    } catch {
-      throw new Error(
-        "@anthropic-ai/sdk is required for AnthropicProvider. Install it: npm install @anthropic-ai/sdk"
-      );
-    }
-  }
-  getClient(apiKey) {
-    if (apiKey) {
-      let cached = this.clientCache.get(apiKey);
-      if (!cached) {
-        cached = new this.AnthropicCtor({ apiKey });
-        this.clientCache.set(apiKey, cached);
-      }
-      return cached;
-    }
-    if (this.client) return this.client;
-    const envKey = process.env.ANTHROPIC_API_KEY;
-    if (envKey) {
-      this.client = new this.AnthropicCtor({ apiKey: envKey });
-      return this.client;
-    }
-    throw new Error("No Anthropic API key provided. Pass it via the x-anthropic-api-key header, apiKey in request body, or set ANTHROPIC_API_KEY env var.");
-  }
-  async generate(messages, options) {
-    const { systemMsg, anthropicMessages } = this.toAnthropicMessages(messages);
-    const params = {
-      model: this.modelId,
-      messages: anthropicMessages,
-      max_tokens: options?.maxTokens ?? 4096
-    };
-    if (systemMsg) params.system = systemMsg;
-    if (options?.temperature !== void 0)
-      params.temperature = options.temperature;
-    if (options?.topP !== void 0) params.top_p = options.topP;
-    if (options?.stop) params.stop_sequences = options.stop;
-    if (options?.tools?.length) {
-      params.tools = this.toAnthropicTools(options.tools);
-    }
-    const client = this.getClient(options?.apiKey);
-    const response = await client.messages.create(params);
-    return this.normalizeResponse(response);
-  }
-  async *stream(messages, options) {
-    const { systemMsg, anthropicMessages } = this.toAnthropicMessages(messages);
-    const params = {
-      model: this.modelId,
-      messages: anthropicMessages,
-      max_tokens: options?.maxTokens ?? 4096,
-      stream: true
-    };
-    if (systemMsg) params.system = systemMsg;
-    if (options?.temperature !== void 0)
-      params.temperature = options.temperature;
-    if (options?.topP !== void 0) params.top_p = options.topP;
-    if (options?.stop) params.stop_sequences = options.stop;
-    if (options?.tools?.length) {
-      params.tools = this.toAnthropicTools(options.tools);
-    }
-    const client = this.getClient(options?.apiKey);
-    const stream = await client.messages.create(params);
-    let currentToolId = "";
-    for await (const event of stream) {
-      switch (event.type) {
-        case "content_block_start": {
-          if (event.content_block?.type === "tool_use") {
-            currentToolId = event.content_block.id;
-            yield {
-              type: "tool_call_start",
-              toolCall: {
-                id: event.content_block.id,
-                name: event.content_block.name
-              }
-            };
-          }
-          break;
-        }
-        case "content_block_delta": {
-          if (event.delta?.type === "text_delta") {
-            yield { type: "text", text: event.delta.text };
-          } else if (event.delta?.type === "input_json_delta") {
-            yield {
-              type: "tool_call_delta",
-              toolCallId: currentToolId,
-              argumentsDelta: event.delta.partial_json
-            };
-          }
-          break;
-        }
-        case "content_block_stop": {
-          if (currentToolId) {
-            yield { type: "tool_call_end", toolCallId: currentToolId };
-            currentToolId = "";
-          }
-          break;
-        }
-        case "message_delta": {
-          const usage = event.usage ? {
-            promptTokens: 0,
-            completionTokens: event.usage.output_tokens ?? 0,
-            totalTokens: event.usage.output_tokens ?? 0
-          } : void 0;
-          let finishReason = event.delta?.stop_reason ?? "stop";
-          if (finishReason === "tool_use") finishReason = "tool_calls";
-          if (finishReason === "end_turn") finishReason = "stop";
-          yield { type: "finish", finishReason, usage };
-          break;
-        }
-        case "message_start": {
-          if (event.message?.usage) {
-          }
-          break;
-        }
-      }
-    }
-  }
-  toAnthropicMessages(messages) {
-    let systemMsg;
-    const anthropicMessages = [];
-    for (const msg of messages) {
-      if (msg.role === "system") {
-        systemMsg = getTextContent(msg.content) || void 0;
-        continue;
-      }
-      if (msg.role === "user") {
-        if (isMultiModal(msg.content)) {
-          anthropicMessages.push({
-            role: "user",
-            content: msg.content.map((p) => this.partToAnthropic(p))
-          });
-        } else {
-          anthropicMessages.push({
-            role: "user",
-            content: [{ type: "text", text: msg.content ?? "" }]
-          });
-        }
-        continue;
-      }
-      if (msg.role === "assistant") {
-        const content = [];
-        if (msg.content) {
-          content.push({ type: "text", text: msg.content });
-        }
-        if (msg.toolCalls) {
-          for (const tc of msg.toolCalls) {
-            content.push({
-              type: "tool_use",
-              id: tc.id,
-              name: tc.name,
-              input: tc.arguments
-            });
-          }
-        }
-        anthropicMessages.push({
-          role: "assistant",
-          content: content.length > 0 ? content : [{ type: "text", text: "" }]
-        });
-        continue;
-      }
-      if (msg.role === "tool") {
-        anthropicMessages.push({
-          role: "user",
-          content: [
-            {
-              type: "tool_result",
-              tool_use_id: msg.toolCallId,
-              content: msg.content ?? ""
-            }
-          ]
-        });
-        continue;
-      }
-    }
-    return { systemMsg, anthropicMessages };
-  }
-  partToAnthropic(part) {
-    switch (part.type) {
-      case "text":
-        return { type: "text", text: part.text };
-      case "image": {
-        const isUrl = part.data.startsWith("http://") || part.data.startsWith("https://");
-        if (isUrl) {
-          return { type: "image", source: { type: "url", url: part.data } };
-        }
-        return {
-          type: "image",
-          source: {
-            type: "base64",
-            media_type: part.mimeType ?? "image/png",
-            data: part.data
-          }
-        };
-      }
-      case "audio":
-        return {
-          type: "text",
-          text: `[Audio content: ${part.mimeType ?? "audio"}]`
-        };
-      case "file":
-        if (part.mimeType === "application/pdf") {
-          return {
-            type: "document",
-            source: { type: "base64", media_type: "application/pdf", data: part.data }
-          };
-        }
-        return {
-          type: "text",
-          text: `[File: ${part.filename ?? "attachment"} (${part.mimeType})]`
-        };
-    }
-  }
-  toAnthropicTools(tools) {
-    return tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: t.parameters
-    }));
-  }
-  normalizeResponse(response) {
-    const toolCalls = [];
-    let textContent = "";
-    for (const block of response.content ?? []) {
-      if (block.type === "text") {
-        textContent += block.text;
-      } else if (block.type === "tool_use") {
-        toolCalls.push({
-          id: block.id,
-          name: block.name,
-          arguments: block.input ?? {}
-        });
-      }
-    }
-    const usage = {
-      promptTokens: response.usage?.input_tokens ?? 0,
-      completionTokens: response.usage?.output_tokens ?? 0,
-      totalTokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0)
-    };
-    let finishReason = "stop";
-    if (response.stop_reason === "tool_use") finishReason = "tool_calls";
-    else if (response.stop_reason === "max_tokens") finishReason = "length";
-    return {
-      message: {
-        role: "assistant",
-        content: textContent || null,
-        toolCalls: toolCalls.length > 0 ? toolCalls : void 0
-      },
-      usage,
-      finishReason,
-      raw: response
-    };
-  }
-};
-
-// src/models/providers/google.ts
-import { createRequire as createRequire5 } from "module";
-var _require5 = createRequire5(import.meta.url);
-var GoogleProvider = class {
-  providerId = "google";
-  modelId;
-  ai;
-  GoogleGenAICtor;
-  clientCache = /* @__PURE__ */ new Map();
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    try {
-      const { GoogleGenAI } = _require5("@google/genai");
-      this.GoogleGenAICtor = GoogleGenAI;
-      const key = config?.apiKey ?? process.env.GOOGLE_API_KEY;
-      if (key) {
-        this.ai = new GoogleGenAI({ apiKey: key });
-      }
-    } catch {
-      throw new Error(
-        "@google/genai is required for GoogleProvider. Install it: npm install @google/genai"
-      );
-    }
-  }
-  getClient(apiKey) {
-    if (apiKey) {
-      let cached = this.clientCache.get(apiKey);
-      if (!cached) {
-        cached = new this.GoogleGenAICtor({ apiKey });
-        this.clientCache.set(apiKey, cached);
-      }
-      return cached;
-    }
-    if (this.ai) return this.ai;
-    const envKey = process.env.GOOGLE_API_KEY;
-    if (envKey) {
-      this.ai = new this.GoogleGenAICtor({ apiKey: envKey });
-      return this.ai;
-    }
-    throw new Error("No Google API key provided. Pass it via the x-google-api-key header, apiKey in request body, or set GOOGLE_API_KEY env var.");
-  }
-  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(options?.apiKey);
-    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(options?.apiKey);
-    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 = `google_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
-        };
-      }
-    }
-  }
-  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: `google_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/providers/ollama.ts
-import { createRequire as createRequire6 } from "module";
-var _require6 = createRequire6(import.meta.url);
-var OllamaProvider = class {
-  providerId = "ollama";
-  modelId;
-  client;
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    try {
-      const { Ollama } = _require6("ollama");
-      this.client = new Ollama({
-        host: config?.host ?? "http://localhost:11434"
-      });
-    } catch {
-      throw new Error(
-        "ollama package is required for OllamaProvider. Install it: npm install ollama"
-      );
-    }
-  }
-  async generate(messages, options) {
-    const params = {
-      model: this.modelId,
-      messages: this.toOllamaMessages(messages),
-      stream: false
-    };
-    const ollamaOptions = {};
-    if (options?.temperature !== void 0)
-      ollamaOptions.temperature = options.temperature;
-    if (options?.topP !== void 0) ollamaOptions.top_p = options.topP;
-    if (options?.stop) ollamaOptions.stop = options.stop;
-    if (options?.maxTokens !== void 0)
-      ollamaOptions.num_predict = options.maxTokens;
-    if (Object.keys(ollamaOptions).length > 0) params.options = ollamaOptions;
-    if (options?.tools?.length) {
-      params.tools = this.toOllamaTools(options.tools);
-    }
-    if (options?.responseFormat === "json") {
-      params.format = "json";
-    }
-    const response = await this.client.chat(params);
-    return this.normalizeResponse(response);
-  }
-  async *stream(messages, options) {
-    const params = {
-      model: this.modelId,
-      messages: this.toOllamaMessages(messages),
-      stream: true
-    };
-    const ollamaOptions = {};
-    if (options?.temperature !== void 0)
-      ollamaOptions.temperature = options.temperature;
-    if (options?.topP !== void 0) ollamaOptions.top_p = options.topP;
-    if (options?.stop) ollamaOptions.stop = options.stop;
-    if (options?.maxTokens !== void 0)
-      ollamaOptions.num_predict = options.maxTokens;
-    if (Object.keys(ollamaOptions).length > 0) params.options = ollamaOptions;
-    if (options?.tools?.length) {
-      params.tools = this.toOllamaTools(options.tools);
-    }
-    if (options?.responseFormat === "json") {
-      params.format = "json";
-    }
-    const stream = await this.client.chat(params);
-    let toolCallCounter = 0;
-    for await (const chunk of stream) {
-      if (chunk.message?.content) {
-        yield { type: "text", text: chunk.message.content };
-      }
-      if (chunk.message?.tool_calls) {
-        for (const tc of chunk.message.tool_calls) {
-          const id = `ollama_tc_${toolCallCounter++}`;
-          yield {
-            type: "tool_call_start",
-            toolCall: {
-              id,
-              name: tc.function?.name ?? ""
-            }
-          };
-          yield {
-            type: "tool_call_delta",
-            toolCallId: id,
-            argumentsDelta: JSON.stringify(tc.function?.arguments ?? {})
-          };
-          yield { type: "tool_call_end", toolCallId: id };
-        }
-      }
-      if (chunk.done) {
-        const hasToolCalls = chunk.message?.tool_calls?.length > 0;
-        yield {
-          type: "finish",
-          finishReason: hasToolCalls ? "tool_calls" : "stop",
-          usage: {
-            promptTokens: chunk.prompt_eval_count ?? 0,
-            completionTokens: chunk.eval_count ?? 0,
-            totalTokens: (chunk.prompt_eval_count ?? 0) + (chunk.eval_count ?? 0)
-          }
-        };
-      }
-    }
-  }
-  toOllamaMessages(messages) {
-    return messages.map((msg) => {
-      if (msg.role === "assistant" && msg.toolCalls?.length) {
-        return {
-          role: "assistant",
-          content: msg.content ?? "",
-          tool_calls: msg.toolCalls.map((tc) => ({
-            function: {
-              name: tc.name,
-              arguments: tc.arguments
-            }
-          }))
-        };
-      }
-      if (msg.role === "tool") {
-        return {
-          role: "tool",
-          content: msg.content ?? ""
-        };
-      }
-      return {
-        role: msg.role,
-        content: msg.content ?? ""
-      };
-    });
-  }
-  toOllamaTools(tools) {
-    return tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters
-      }
-    }));
-  }
-  normalizeResponse(response) {
-    const toolCalls = (response.message?.tool_calls ?? []).map(
-      (tc, i) => ({
-        id: `ollama_tc_${i}`,
-        name: tc.function?.name ?? "",
-        arguments: tc.function?.arguments ?? {}
-      })
-    );
-    const usage = {
-      promptTokens: response.prompt_eval_count ?? 0,
-      completionTokens: response.eval_count ?? 0,
-      totalTokens: (response.prompt_eval_count ?? 0) + (response.eval_count ?? 0)
-    };
-    const hasToolCalls = toolCalls.length > 0;
-    return {
-      message: {
-        role: "assistant",
-        content: response.message?.content ?? null,
-        toolCalls: hasToolCalls ? toolCalls : void 0
-      },
-      usage,
-      finishReason: hasToolCalls ? "tool_calls" : "stop",
-      raw: response
-    };
-  }
-};
-
-// 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();
-  register(providerId, factory) {
-    this.factories.set(providerId, factory);
-  }
-  resolve(providerId, modelId, config) {
-    const factory = this.factories.get(providerId);
-    if (!factory) {
-      throw new Error(
-        `Unknown provider "${providerId}". Register it first with registry.register().`
-      );
-    }
-    return factory(modelId, config);
-  }
-  has(providerId) {
-    return this.factories.has(providerId);
-  }
-};
-var registry = new ModelRegistry();
-registry.register(
-  "openai",
-  (modelId, config) => new OpenAIProvider(modelId, config)
-);
-registry.register(
-  "anthropic",
-  (modelId, config) => new AnthropicProvider(modelId, config)
-);
-registry.register(
-  "google",
-  (modelId, config) => new GoogleProvider(modelId, config)
-);
-registry.register(
-  "ollama",
-  (modelId, config) => new OllamaProvider(modelId, config)
-);
-function openai(modelId, config) {
-  return registry.resolve("openai", modelId, config);
-}
-function anthropic(modelId, config) {
-  return registry.resolve("anthropic", modelId, config);
-}
-function google(modelId, config) {
-  return registry.resolve("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) {
-  return {
-    name: config.name,
-    description: config.description,
-    parameters: config.parameters,
-    execute: config.execute
-  };
-}
-
-// src/storage/sqlite.ts
-import { createRequire as createRequire8 } from "module";
-var _require8 = createRequire8(import.meta.url);
-var SqliteStorage = class {
-  db;
-  constructor(dbPath) {
-    try {
-      const Database = _require8("better-sqlite3");
-      this.db = new Database(dbPath);
-      this.db.pragma("journal_mode = WAL");
-      this.db.exec(`
-        CREATE TABLE IF NOT EXISTS kv_store (
-          namespace TEXT NOT NULL,
-          key TEXT NOT NULL,
-          value TEXT NOT NULL,
-          updated_at TEXT DEFAULT (datetime('now')),
-          PRIMARY KEY (namespace, key)
-        )
-      `);
-    } catch {
-      throw new Error(
-        "better-sqlite3 is required for SqliteStorage. Install it: npm install better-sqlite3"
-      );
-    }
-  }
-  async get(namespace, key) {
-    const row = this.db.prepare("SELECT value FROM kv_store WHERE namespace = ? AND key = ?").get(namespace, key);
-    if (!row) return null;
-    return JSON.parse(row.value);
-  }
-  async set(namespace, key, value) {
-    this.db.prepare(
-      `INSERT INTO kv_store (namespace, key, value, updated_at)
-         VALUES (?, ?, ?, datetime('now'))
-         ON CONFLICT(namespace, key)
-         DO UPDATE SET value = excluded.value, updated_at = datetime('now')`
-    ).run(namespace, key, JSON.stringify(value));
-  }
-  async delete(namespace, key) {
-    this.db.prepare("DELETE FROM kv_store WHERE namespace = ? AND key = ?").run(namespace, key);
-  }
-  async list(namespace, prefix) {
-    const rows = prefix ? this.db.prepare(
-      "SELECT key, value FROM kv_store WHERE namespace = ? AND key LIKE ?"
-    ).all(namespace, `${prefix}%`) : this.db.prepare("SELECT key, value FROM kv_store WHERE namespace = ?").all(namespace);
-    return rows.map((row) => ({
-      key: row.key,
-      value: JSON.parse(row.value)
-    }));
-  }
-  async close() {
-    this.db.close();
-  }
-};
-
-// src/storage/postgres.ts
-import { createRequire as createRequire9 } from "module";
-var _require9 = createRequire9(import.meta.url);
-var PostgresStorage = class {
-  pool;
-  constructor(connectionString) {
-    try {
-      const { Pool } = _require9("pg");
-      this.pool = new Pool({ connectionString });
-    } catch {
-      throw new Error(
-        "pg is required for PostgresStorage. Install it: npm install pg"
-      );
-    }
-  }
-  async initialize() {
-    await this.pool.query(`
-      CREATE TABLE IF NOT EXISTS kv_store (
-        namespace TEXT NOT NULL,
-        key TEXT NOT NULL,
-        value JSONB NOT NULL,
-        updated_at TIMESTAMPTZ DEFAULT NOW(),
-        PRIMARY KEY (namespace, key)
-      )
-    `);
-  }
-  async get(namespace, key) {
-    const result = await this.pool.query(
-      "SELECT value FROM kv_store WHERE namespace = $1 AND key = $2",
-      [namespace, key]
-    );
-    if (result.rows.length === 0) return null;
-    return result.rows[0].value;
-  }
-  async set(namespace, key, value) {
-    await this.pool.query(
-      `INSERT INTO kv_store (namespace, key, value, updated_at)
-       VALUES ($1, $2, $3, NOW())
-       ON CONFLICT (namespace, key)
-       DO UPDATE SET value = EXCLUDED.value, updated_at = NOW()`,
-      [namespace, key, JSON.stringify(value)]
-    );
-  }
-  async delete(namespace, key) {
-    await this.pool.query(
-      "DELETE FROM kv_store WHERE namespace = $1 AND key = $2",
-      [namespace, key]
-    );
-  }
-  async list(namespace, prefix) {
-    const result = prefix ? await this.pool.query(
-      "SELECT key, value FROM kv_store WHERE namespace = $1 AND key LIKE $2",
-      [namespace, `${prefix}%`]
-    ) : await this.pool.query(
-      "SELECT key, value FROM kv_store WHERE namespace = $1",
-      [namespace]
-    );
-    return result.rows.map((row) => ({
-      key: row.key,
-      value: row.value
-    }));
-  }
-  async close() {
-    await this.pool.end();
-  }
-};
-
-// src/storage/mongodb.ts
-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 } = _require10("mongodb");
-      this.client = new MongoClient(uri);
-    } catch {
-      throw new Error(
-        "mongodb is required for MongoDBStorage. Install it: npm install mongodb"
-      );
-    }
-  }
-  client;
-  db;
-  collection;
-  async initialize() {
-    await this.client.connect();
-    this.db = this.client.db(this.dbName);
-    this.collection = this.db.collection(this.collectionName);
-    await this.collection.createIndex(
-      { namespace: 1, key: 1 },
-      { unique: true }
-    );
-  }
-  async get(namespace, key) {
-    const doc = await this.collection.findOne({ namespace, key });
-    if (!doc) return null;
-    return doc.value;
-  }
-  async set(namespace, key, value) {
-    await this.collection.updateOne(
-      { namespace, key },
-      { $set: { value, updatedAt: /* @__PURE__ */ new Date() } },
-      { upsert: true }
-    );
-  }
-  async delete(namespace, key) {
-    await this.collection.deleteOne({ namespace, key });
-  }
-  async list(namespace, prefix) {
-    const filter = { namespace };
-    if (prefix) {
-      filter.key = { $regex: `^${prefix}` };
-    }
-    const docs = await this.collection.find(filter).toArray();
-    return docs.map((doc) => ({ key: doc.key, value: doc.value }));
-  }
-  async close() {
-    await this.client.close();
-  }
-};
-
-// src/vector/base.ts
-var BaseVectorStore = class {
-  constructor(embedder) {
-    this.embedder = embedder;
-  }
-  async ensureEmbedding(doc) {
-    if (doc.embedding) return doc.embedding;
-    if (!this.embedder) {
-      throw new Error(
-        "No embedding provided on document and no EmbeddingProvider configured"
-      );
-    }
-    return this.embedder.embed(doc.content);
-  }
-  async ensureQueryVector(query) {
-    if (Array.isArray(query)) return query;
-    if (!this.embedder) {
-      throw new Error(
-        "String query requires an EmbeddingProvider to be configured"
-      );
-    }
-    return this.embedder.embed(query);
-  }
-};
-
-// src/vector/in-memory.ts
-var InMemoryVectorStore = class extends BaseVectorStore {
-  collections = /* @__PURE__ */ new Map();
-  constructor(embedder) {
-    super(embedder);
-  }
-  async initialize() {
-  }
-  getCol(collection) {
-    let col = this.collections.get(collection);
-    if (!col) {
-      col = /* @__PURE__ */ new Map();
-      this.collections.set(collection, col);
-    }
-    return col;
-  }
-  async upsert(collection, doc) {
-    const embedding = await this.ensureEmbedding(doc);
-    this.getCol(collection).set(doc.id, {
-      id: doc.id,
-      content: doc.content,
-      embedding,
-      metadata: doc.metadata ?? {}
-    });
-  }
-  async upsertBatch(collection, docs) {
-    for (const doc of docs) {
-      await this.upsert(collection, doc);
-    }
-  }
-  async search(collection, query, options) {
-    const vec = await this.ensureQueryVector(query);
-    const topK = options?.topK ?? 10;
-    const col = this.getCol(collection);
-    const scored = [];
-    for (const doc of col.values()) {
-      const score = this.cosineSimilarity(vec, doc.embedding);
-      if (options?.minScore != null && score < options.minScore) continue;
-      if (options?.filter) {
-        let match = true;
-        for (const [k, v] of Object.entries(options.filter)) {
-          if (doc.metadata[k] !== v) {
-            match = false;
-            break;
-          }
-        }
-        if (!match) continue;
-      }
-      scored.push({
-        id: doc.id,
-        content: doc.content,
-        score,
-        metadata: doc.metadata
-      });
-    }
-    scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, topK);
-  }
-  cosineSimilarity(a, b) {
-    let dot = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-      dot += a[i] * b[i];
-      normA += a[i] * a[i];
-      normB += b[i] * b[i];
-    }
-    const denom = Math.sqrt(normA) * Math.sqrt(normB);
-    return denom === 0 ? 0 : dot / denom;
-  }
-  async delete(collection, id) {
-    this.getCol(collection).delete(id);
-  }
-  async get(collection, id) {
-    const doc = this.getCol(collection).get(id);
-    if (!doc) return null;
-    return { id: doc.id, content: doc.content, metadata: doc.metadata };
-  }
-  async dropCollection(collection) {
-    this.collections.delete(collection);
-  }
-  async close() {
-    this.collections.clear();
-  }
-};
-
-// src/vector/pgvector.ts
-import { createRequire as createRequire11 } from "module";
-var _require11 = createRequire11(import.meta.url);
-var PgVectorStore = class extends BaseVectorStore {
-  pool;
-  dimensions;
-  initializedCollections = /* @__PURE__ */ new Set();
-  constructor(config, embedder) {
-    super(embedder);
-    this.dimensions = config.dimensions ?? embedder?.dimensions ?? 1536;
-    try {
-      const { Pool } = _require11("pg");
-      this.pool = new Pool({ connectionString: config.connectionString });
-    } catch {
-      throw new Error(
-        "pg is required for PgVectorStore. Install it: npm install pg"
-      );
-    }
-  }
-  async initialize() {
-    await this.pool.query("CREATE EXTENSION IF NOT EXISTS vector");
-  }
-  async ensureCollection(collection) {
-    if (this.initializedCollections.has(collection)) return;
-    const table = this.sanitize(collection);
-    await this.pool.query(`
-      CREATE TABLE IF NOT EXISTS ${table} (
-        id TEXT PRIMARY KEY,
-        content TEXT NOT NULL,
-        embedding vector(${this.dimensions}),
-        metadata JSONB DEFAULT '{}'::jsonb,
-        created_at TIMESTAMPTZ DEFAULT NOW()
-      )
-    `);
-    await this.pool.query(`
-      CREATE INDEX IF NOT EXISTS ${table}_embedding_idx
-      ON ${table} USING ivfflat (embedding vector_cosine_ops)
-      WITH (lists = 100)
-    `).catch(() => {
-    });
-    this.initializedCollections.add(collection);
-  }
-  sanitize(name) {
-    return name.replace(/[^a-zA-Z0-9_]/g, "_");
-  }
-  toSql(vec) {
-    return `[${vec.join(",")}]`;
-  }
-  async upsert(collection, doc) {
-    await this.ensureCollection(collection);
-    const embedding = await this.ensureEmbedding(doc);
-    const table = this.sanitize(collection);
-    await this.pool.query(
-      `INSERT INTO ${table} (id, content, embedding, metadata)
-       VALUES ($1, $2, $3::vector, $4::jsonb)
-       ON CONFLICT (id)
-       DO UPDATE SET content = EXCLUDED.content,
-                     embedding = EXCLUDED.embedding,
-                     metadata = EXCLUDED.metadata`,
-      [doc.id, doc.content, this.toSql(embedding), JSON.stringify(doc.metadata ?? {})]
-    );
-  }
-  async upsertBatch(collection, docs) {
-    for (const doc of docs) {
-      await this.upsert(collection, doc);
-    }
-  }
-  async search(collection, query, options) {
-    await this.ensureCollection(collection);
-    const vec = await this.ensureQueryVector(query);
-    const topK = options?.topK ?? 10;
-    const table = this.sanitize(collection);
-    let filterClause = "";
-    const params = [this.toSql(vec), topK];
-    if (options?.filter) {
-      const conditions = Object.entries(options.filter).map(([k, v], i) => {
-        params.push(JSON.stringify(v));
-        return `metadata->>'${k.replace(/'/g, "''")}' = $${i + 3}`;
-      });
-      if (conditions.length > 0) {
-        filterClause = `WHERE ${conditions.join(" AND ")}`;
-      }
-    }
-    const result = await this.pool.query(
-      `SELECT id, content, metadata,
-              1 - (embedding <=> $1::vector) AS score
-       FROM ${table}
-       ${filterClause}
-       ORDER BY embedding <=> $1::vector
-       LIMIT $2`,
-      params
-    );
-    let rows = result.rows;
-    if (options?.minScore != null) {
-      rows = rows.filter((r) => r.score >= options.minScore);
-    }
-    return rows.map((r) => ({
-      id: r.id,
-      content: r.content,
-      score: r.score,
-      metadata: r.metadata
-    }));
-  }
-  async delete(collection, id) {
-    await this.ensureCollection(collection);
-    const table = this.sanitize(collection);
-    await this.pool.query(`DELETE FROM ${table} WHERE id = $1`, [id]);
-  }
-  async get(collection, id) {
-    await this.ensureCollection(collection);
-    const table = this.sanitize(collection);
-    const result = await this.pool.query(
-      `SELECT id, content, metadata FROM ${table} WHERE id = $1`,
-      [id]
-    );
-    if (result.rows.length === 0) return null;
-    const row = result.rows[0];
-    return { id: row.id, content: row.content, metadata: row.metadata };
-  }
-  async dropCollection(collection) {
-    const table = this.sanitize(collection);
-    await this.pool.query(`DROP TABLE IF EXISTS ${table}`);
-    this.initializedCollections.delete(collection);
-  }
-  async close() {
-    await this.pool.end();
-  }
-};
-
-// src/vector/qdrant.ts
-import { createRequire as createRequire12 } from "module";
-import { createHash } from "crypto";
-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");
-  return [
-    hex.slice(0, 8),
-    hex.slice(8, 12),
-    "4" + hex.slice(13, 16),
-    "8" + hex.slice(17, 20),
-    hex.slice(20, 32)
-  ].join("-");
-}
-function toQdrantId(id) {
-  if (/^\d+$/.test(id)) return Number(id);
-  if (UUID_RE.test(id)) return id;
-  return stringToUUID(id);
-}
-var QdrantVectorStore = class extends BaseVectorStore {
-  client;
-  dimensions;
-  initializedCollections = /* @__PURE__ */ new Set();
-  constructor(config = {}, embedder) {
-    super(embedder);
-    this.dimensions = config.dimensions ?? embedder?.dimensions ?? 1536;
-    try {
-      const { QdrantClient } = _require12("@qdrant/js-client-rest");
-      this.client = new QdrantClient({
-        url: config.url ?? "http://localhost:6333",
-        apiKey: config.apiKey,
-        checkCompatibility: config.checkCompatibility ?? false
-      });
-    } catch {
-      throw new Error(
-        "@qdrant/js-client-rest is required for QdrantVectorStore. Install it: npm install @qdrant/js-client-rest"
-      );
-    }
-  }
-  async initialize() {
-  }
-  async ensureCollection(collection) {
-    if (this.initializedCollections.has(collection)) return;
-    try {
-      await this.client.getCollection(collection);
-    } catch {
-      await this.client.createCollection(collection, {
-        vectors: {
-          size: this.dimensions,
-          distance: "Cosine"
-        }
-      });
-    }
-    this.initializedCollections.add(collection);
-  }
-  async upsert(collection, doc) {
-    await this.ensureCollection(collection);
-    const embedding = await this.ensureEmbedding(doc);
-    await this.client.upsert(collection, {
-      wait: true,
-      points: [
-        {
-          id: toQdrantId(doc.id),
-          vector: embedding,
-          payload: {
-            _originalId: doc.id,
-            content: doc.content,
-            ...doc.metadata ?? {}
-          }
-        }
-      ]
-    });
-  }
-  async upsertBatch(collection, docs) {
-    await this.ensureCollection(collection);
-    const points = await Promise.all(
-      docs.map(async (doc) => {
-        const embedding = await this.ensureEmbedding(doc);
-        return {
-          id: toQdrantId(doc.id),
-          vector: embedding,
-          payload: {
-            _originalId: doc.id,
-            content: doc.content,
-            ...doc.metadata ?? {}
-          }
-        };
-      })
-    );
-    await this.client.upsert(collection, { wait: true, points });
-  }
-  async search(collection, query, options) {
-    await this.ensureCollection(collection);
-    const vec = await this.ensureQueryVector(query);
-    const topK = options?.topK ?? 10;
-    const searchParams = {
-      vector: vec,
-      limit: topK,
-      with_payload: true
-    };
-    if (options?.filter) {
-      searchParams.filter = {
-        must: Object.entries(options.filter).map(([key, value]) => ({
-          key,
-          match: { value }
-        }))
-      };
-    }
-    if (options?.minScore != null) {
-      searchParams.score_threshold = options.minScore;
-    }
-    const results = await this.client.search(collection, searchParams);
-    return results.map((r) => {
-      const { _originalId, content, ...rest } = r.payload ?? {};
-      return {
-        id: _originalId ?? String(r.id),
-        content: content ?? "",
-        score: r.score,
-        metadata: rest
-      };
-    });
-  }
-  async delete(collection, id) {
-    await this.ensureCollection(collection);
-    await this.client.delete(collection, {
-      wait: true,
-      points: [toQdrantId(id)]
-    });
-  }
-  async get(collection, id) {
-    await this.ensureCollection(collection);
-    try {
-      const results = await this.client.retrieve(collection, {
-        ids: [toQdrantId(id)],
-        with_payload: true
-      });
-      if (!results || results.length === 0) return null;
-      const point = results[0];
-      const { _originalId, content, ...rest } = point.payload ?? {};
-      return {
-        id: _originalId ?? String(point.id),
-        content: content ?? "",
-        metadata: rest
-      };
-    } catch {
-      return null;
-    }
-  }
-  async dropCollection(collection) {
-    try {
-      await this.client.deleteCollection(collection);
-    } catch {
-    }
-    this.initializedCollections.delete(collection);
-  }
-  async close() {
-  }
-};
-
-// src/vector/mongodb.ts
-import { createRequire as createRequire13 } from "module";
-var _require13 = createRequire13(import.meta.url);
-var MongoDBVectorStore = class extends BaseVectorStore {
-  client;
-  db;
-  indexName;
-  dbName;
-  useAtlas = null;
-  constructor(config, embedder) {
-    super(embedder);
-    this.indexName = config.indexName ?? "vector_index";
-    this.dbName = config.dbName ?? "radaros_vectors";
-    try {
-      const { MongoClient } = _require13("mongodb");
-      this.client = new MongoClient(config.uri);
-    } catch {
-      throw new Error(
-        "mongodb is required for MongoDBVectorStore. Install it: npm install mongodb"
-      );
-    }
-  }
-  async initialize() {
-    await this.client.connect();
-    this.db = this.client.db(this.dbName);
-  }
-  col(collection) {
-    return this.db.collection(collection);
-  }
-  async upsert(collection, doc) {
-    const embedding = await this.ensureEmbedding(doc);
-    await this.col(collection).updateOne(
-      { _id: doc.id },
-      {
-        $set: {
-          content: doc.content,
-          embedding,
-          metadata: doc.metadata ?? {},
-          updatedAt: /* @__PURE__ */ new Date()
-        }
-      },
-      { upsert: true }
-    );
-  }
-  async upsertBatch(collection, docs) {
-    const ops = await Promise.all(
-      docs.map(async (doc) => {
-        const embedding = await this.ensureEmbedding(doc);
-        return {
-          updateOne: {
-            filter: { _id: doc.id },
-            update: {
-              $set: {
-                content: doc.content,
-                embedding,
-                metadata: doc.metadata ?? {},
-                updatedAt: /* @__PURE__ */ new Date()
-              }
-            },
-            upsert: true
-          }
-        };
-      })
-    );
-    if (ops.length > 0) {
-      await this.col(collection).bulkWrite(ops);
-    }
-  }
-  async search(collection, query, options) {
-    const vec = await this.ensureQueryVector(query);
-    if (this.useAtlas === true) {
-      return this.atlasSearch(collection, vec, options);
-    }
-    if (this.useAtlas === false) {
-      return this.localSearch(collection, vec, options);
-    }
-    try {
-      const results = await this.atlasSearch(collection, vec, options);
-      this.useAtlas = true;
-      return results;
-    } catch {
-      this.useAtlas = false;
-      return this.localSearch(collection, vec, options);
-    }
-  }
-  async atlasSearch(collection, vec, options) {
-    const topK = options?.topK ?? 10;
-    const pipeline = [
-      {
-        $vectorSearch: {
-          index: this.indexName,
-          path: "embedding",
-          queryVector: vec,
-          numCandidates: topK * 10,
-          limit: topK,
-          ...options?.filter ? { filter: this.buildFilter(options.filter) } : {}
-        }
-      },
-      {
-        $addFields: {
-          score: { $meta: "vectorSearchScore" }
-        }
-      }
-    ];
-    if (options?.minScore != null) {
-      pipeline.push({ $match: { score: { $gte: options.minScore } } });
-    }
-    pipeline.push({
-      $project: { _id: 1, content: 1, score: 1, metadata: 1 }
-    });
-    const results = await this.col(collection).aggregate(pipeline).toArray();
-    return results.map((r) => ({
-      id: String(r._id),
-      content: r.content ?? "",
-      score: r.score,
-      metadata: r.metadata
-    }));
-  }
-  async localSearch(collection, vec, options) {
-    const topK = options?.topK ?? 10;
-    const filter = {};
-    if (options?.filter) {
-      for (const [k, v] of Object.entries(options.filter)) {
-        filter[`metadata.${k}`] = v;
-      }
-    }
-    const docs = await this.col(collection).find(filter, { projection: { _id: 1, content: 1, embedding: 1, metadata: 1 } }).toArray();
-    const scored = [];
-    for (const doc of docs) {
-      if (!doc.embedding) continue;
-      const score = cosine(vec, doc.embedding);
-      if (options?.minScore != null && score < options.minScore) continue;
-      scored.push({
-        id: String(doc._id),
-        content: doc.content ?? "",
-        score,
-        metadata: doc.metadata
-      });
-    }
-    scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, topK);
-  }
-  buildFilter(filter) {
-    const conditions = {};
-    for (const [key, value] of Object.entries(filter)) {
-      conditions[`metadata.${key}`] = value;
-    }
-    return conditions;
-  }
-  async delete(collection, id) {
-    await this.col(collection).deleteOne({ _id: id });
-  }
-  async get(collection, id) {
-    const doc = await this.col(collection).findOne({ _id: id });
-    if (!doc) return null;
-    return {
-      id: String(doc._id),
-      content: doc.content,
-      metadata: doc.metadata
-    };
-  }
-  async dropCollection(collection) {
-    try {
-      await this.col(collection).drop();
-    } catch {
-    }
-  }
-  async close() {
-    await this.client.close();
-  }
-};
-function cosine(a, b) {
-  let dot = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  return denom === 0 ? 0 : dot / denom;
-}
-
-// src/vector/embeddings/openai.ts
-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,
-  "text-embedding-ada-002": 1536
-};
-var OpenAIEmbedding = class {
-  dimensions;
-  client;
-  model;
-  constructor(config = {}) {
-    this.model = config.model ?? "text-embedding-3-small";
-    this.dimensions = config.dimensions ?? MODEL_DIMENSIONS[this.model] ?? 1536;
-    try {
-      const mod = _require14("openai");
-      const OpenAI = mod.default ?? mod;
-      this.client = new OpenAI({
-        apiKey: config.apiKey ?? process.env.OPENAI_API_KEY,
-        baseURL: config.baseURL
-      });
-    } catch {
-      throw new Error(
-        "openai package is required for OpenAIEmbedding. Install it: npm install openai"
-      );
-    }
-  }
-  async embed(text) {
-    const response = await this.client.embeddings.create({
-      model: this.model,
-      input: text,
-      ...this.dimensions !== MODEL_DIMENSIONS[this.model] ? { dimensions: this.dimensions } : {}
-    });
-    return response.data[0].embedding;
-  }
-  async embedBatch(texts) {
-    const response = await this.client.embeddings.create({
-      model: this.model,
-      input: texts,
-      ...this.dimensions !== MODEL_DIMENSIONS[this.model] ? { dimensions: this.dimensions } : {}
-    });
-    return response.data.sort((a, b) => a.index - b.index).map((d) => d.embedding);
-  }
-};
-
-// src/vector/embeddings/google.ts
-import { createRequire as createRequire15 } from "module";
-var _require15 = createRequire15(import.meta.url);
-var MODEL_DIMENSIONS2 = {
-  "text-embedding-004": 768,
-  "embedding-001": 768
-};
-var GoogleEmbedding = class {
-  dimensions;
-  ai;
-  model;
-  constructor(config = {}) {
-    this.model = config.model ?? "text-embedding-004";
-    this.dimensions = config.dimensions ?? MODEL_DIMENSIONS2[this.model] ?? 768;
-    try {
-      const { GoogleGenAI } = _require15("@google/genai");
-      this.ai = new GoogleGenAI({
-        apiKey: config.apiKey ?? process.env.GOOGLE_API_KEY
-      });
-    } catch {
-      throw new Error(
-        "@google/genai is required for GoogleEmbedding. Install it: npm install @google/genai"
-      );
-    }
-  }
-  async embed(text) {
-    const result = await this.ai.models.embedContent({
-      model: this.model,
-      contents: text,
-      ...this.dimensions !== MODEL_DIMENSIONS2[this.model] ? { config: { outputDimensionality: this.dimensions } } : {}
-    });
-    return result.embeddings[0].values;
-  }
-  async embedBatch(texts) {
-    const results = await Promise.all(
-      texts.map(
-        (text) => this.ai.models.embedContent({
-          model: this.model,
-          contents: text,
-          ...this.dimensions !== MODEL_DIMENSIONS2[this.model] ? { config: { outputDimensionality: this.dimensions } } : {}
-        })
-      )
-    );
-    return results.map((r) => r.embeddings[0].values);
-  }
-};
-
-// src/knowledge/knowledge-base.ts
-import { z } from "zod";
-var KnowledgeBase = class {
-  name;
-  collection;
-  store;
-  initialized = false;
-  constructor(config) {
-    this.name = config.name;
-    this.store = config.vectorStore;
-    this.collection = config.collection ?? config.name.toLowerCase().replace(/\s+/g, "_");
-  }
-  async initialize() {
-    if (this.initialized) return;
-    await this.store.initialize();
-    this.initialized = true;
-  }
-  async add(doc) {
-    await this.ensureInit();
-    await this.store.upsert(this.collection, doc);
-  }
-  async addDocuments(docs) {
-    await this.ensureInit();
-    await this.store.upsertBatch(this.collection, docs);
-  }
-  async search(query, options) {
-    await this.ensureInit();
-    return this.store.search(this.collection, query, options);
-  }
-  async get(id) {
-    await this.ensureInit();
-    return this.store.get(this.collection, id);
-  }
-  async delete(id) {
-    await this.ensureInit();
-    await this.store.delete(this.collection, id);
-  }
-  async clear() {
-    await this.store.dropCollection(this.collection);
-  }
-  async close() {
-    await this.store.close();
-  }
-  /**
-   * Returns a ToolDef that an Agent can use to search this knowledge base.
-   * Plug the result directly into `Agent({ tools: [kb.asTool()] })`.
-   */
-  asTool(config = {}) {
-    const topK = config.topK ?? 5;
-    const minScore = config.minScore;
-    const filter = config.filter;
-    const toolName = config.toolName ?? `search_${this.collection}`;
-    const description = config.description ?? `Search the "${this.name}" knowledge base for relevant information. Use this before answering questions related to ${this.name}.`;
-    const formatResults = config.formatResults ?? defaultFormatResults;
-    const kb = this;
-    return {
-      name: toolName,
-      description,
-      parameters: z.object({
-        query: z.string().describe("Search query to find relevant documents")
-      }),
-      execute: async (args) => {
-        const results = await kb.search(args.query, {
-          topK,
-          minScore,
-          filter
-        });
-        if (results.length === 0) {
-          return "No relevant documents found in the knowledge base.";
-        }
-        return formatResults(results);
-      }
-    };
-  }
-  async ensureInit() {
-    if (!this.initialized) await this.initialize();
-  }
-};
-function defaultFormatResults(results) {
-  const lines = results.map((r, i) => {
-    const meta = r.metadata ? Object.entries(r.metadata).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}: ${v}`).join(", ") : "";
-    const metaStr = meta ? ` | ${meta}` : "";
-    return `[${i + 1}] (score: ${r.score.toFixed(3)}${metaStr})
-${r.content}`;
-  });
-  return `Found ${results.length} relevant document(s):
-
-${lines.join("\n\n")}`;
-}
-
-// src/memory/memory.ts
-var SHORT_TERM_NS = "memory:short";
-var LONG_TERM_NS = "memory:long";
-var Memory = class {
-  storage;
-  maxShortTermMessages;
-  enableLongTerm;
-  constructor(config) {
-    this.storage = config?.storage ?? new InMemoryStorage();
-    this.maxShortTermMessages = config?.maxShortTermMessages ?? 50;
-    this.enableLongTerm = config?.enableLongTerm ?? false;
-  }
-  async addMessages(sessionId, messages) {
-    const existing = await this.storage.get(SHORT_TERM_NS, sessionId) ?? [];
-    const updated = [...existing, ...messages];
-    if (updated.length > this.maxShortTermMessages) {
-      const overflow = updated.splice(
-        0,
-        updated.length - this.maxShortTermMessages
-      );
-      if (this.enableLongTerm && overflow.length > 0) {
-        await this.summarizeAndStore(sessionId, overflow);
-      }
-    }
-    await this.storage.set(SHORT_TERM_NS, sessionId, updated);
-  }
-  async getMessages(sessionId) {
-    return await this.storage.get(SHORT_TERM_NS, sessionId) ?? [];
-  }
-  async getSummaries(sessionId) {
-    if (!this.enableLongTerm) return [];
-    const entries = await this.storage.list(
-      LONG_TERM_NS,
-      sessionId
-    );
-    return entries.map((e) => e.value.summary);
-  }
-  async getContextString(sessionId) {
-    const summaries = await this.getSummaries(sessionId);
-    if (summaries.length === 0) return "";
-    return `Previous context:
-${summaries.join("\n")}`;
-  }
-  async summarizeAndStore(sessionId, messages) {
-    const textParts = messages.filter((m) => m.content).map((m) => `${m.role}: ${getTextContent(m.content)}`);
-    if (textParts.length === 0) return;
-    const summary = textParts.join(" | ").slice(0, 500);
-    const entry = {
-      key: `${sessionId}:${Date.now()}`,
-      summary,
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    await this.storage.set(LONG_TERM_NS, entry.key, entry);
-  }
-  async clear(sessionId) {
-    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: z7 } = 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, z7);
-      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, z7) {
-    if (!schema || !schema.properties) {
-      return z7.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 = z7.string();
-          if (prop.enum) field = z7.enum(prop.enum);
-          break;
-        case "number":
-        case "integer":
-          field = z7.number();
-          break;
-        case "boolean":
-          field = z7.boolean();
-          break;
-        case "array":
-          field = z7.array(z7.any());
-          break;
-        case "object":
-          field = z7.record(z7.any());
-          break;
-        default:
-          field = z7.any();
-      }
-      if (prop.description) {
-        field = field.describe(prop.description);
-      }
-      if (!required.includes(key)) {
-        field = field.optional();
-      }
-      shape[key] = field;
-    }
-    return z7.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");
-  }
-};
-
-// src/toolkits/base.ts
-var Toolkit = class {
-};
-
-// src/toolkits/websearch.ts
-import { z as z3 } from "zod";
-var WebSearchToolkit = class extends Toolkit {
-  name = "websearch";
-  config;
-  constructor(config) {
-    super();
-    this.config = config;
-  }
-  getApiKey() {
-    if (this.config.apiKey) return this.config.apiKey;
-    const envKey = this.config.provider === "tavily" ? process.env.TAVILY_API_KEY : process.env.SERPAPI_API_KEY;
-    if (!envKey) {
-      const envName = this.config.provider === "tavily" ? "TAVILY_API_KEY" : "SERPAPI_API_KEY";
-      throw new Error(
-        `WebSearchToolkit: No API key provided. Set ${envName} env var or pass apiKey in config.`
-      );
-    }
-    return envKey;
-  }
-  getTools() {
-    const self = this;
-    return [
-      {
-        name: "web_search",
-        description: "Search the web for current information. Returns titles, URLs, and snippets from search results.",
-        parameters: z3.object({
-          query: z3.string().describe("The search query"),
-          maxResults: z3.number().optional().describe("Maximum number of results (default 5)")
-        }),
-        execute: async (args, _ctx) => {
-          const query = args.query;
-          const max = args.maxResults ?? self.config.maxResults ?? 5;
-          if (self.config.provider === "tavily") {
-            return self.searchTavily(query, max);
-          }
-          return self.searchSerpApi(query, max);
-        }
-      }
-    ];
-  }
-  async searchTavily(query, maxResults) {
-    const apiKey = this.getApiKey();
-    const res = await fetch("https://api.tavily.com/search", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        api_key: apiKey,
-        query,
-        max_results: maxResults,
-        include_answer: true
-      })
-    });
-    if (!res.ok) {
-      throw new Error(`Tavily search failed: ${res.status} ${res.statusText}`);
-    }
-    const data = await res.json();
-    const results = [];
-    if (data.answer) {
-      results.push(`Answer: ${data.answer}
-`);
-    }
-    for (const r of data.results ?? []) {
-      results.push(`Title: ${r.title}
-URL: ${r.url}
-Snippet: ${r.content}
-`);
-    }
-    return results.join("\n---\n") || "No results found.";
-  }
-  async searchSerpApi(query, maxResults) {
-    const apiKey = this.getApiKey();
-    const params = new URLSearchParams({
-      q: query,
-      api_key: apiKey,
-      engine: "google",
-      num: String(maxResults)
-    });
-    const res = await fetch(
-      `https://serpapi.com/search.json?${params.toString()}`
-    );
-    if (!res.ok) {
-      throw new Error(
-        `SerpAPI search failed: ${res.status} ${res.statusText}`
-      );
-    }
-    const data = await res.json();
-    const results = [];
-    if (data.answer_box?.answer) {
-      results.push(`Answer: ${data.answer_box.answer}
-`);
-    }
-    for (const r of (data.organic_results ?? []).slice(0, maxResults)) {
-      results.push(
-        `Title: ${r.title}
-URL: ${r.link}
-Snippet: ${r.snippet ?? ""}
-`
-      );
-    }
-    return results.join("\n---\n") || "No results found.";
-  }
-};
-
-// src/toolkits/gmail.ts
-import { z as z4 } from "zod";
-import { createRequire as createRequire16 } from "module";
-var _require16 = createRequire16(import.meta.url);
-var GmailToolkit = class extends Toolkit {
-  name = "gmail";
-  config;
-  gmail = null;
-  constructor(config = {}) {
-    super();
-    this.config = config;
-  }
-  async getGmailClient() {
-    if (this.gmail) return this.gmail;
-    if (this.config.authClient) {
-      const { google: google3 } = _require16("googleapis");
-      this.gmail = google3.gmail({ version: "v1", auth: this.config.authClient });
-      return this.gmail;
-    }
-    const credPath = this.config.credentialsPath ?? process.env.GMAIL_CREDENTIALS_PATH;
-    const tokenPath = this.config.tokenPath ?? process.env.GMAIL_TOKEN_PATH;
-    if (!credPath || !tokenPath) {
-      throw new Error(
-        "GmailToolkit: Provide credentialsPath + tokenPath, or an authClient. Set GMAIL_CREDENTIALS_PATH and GMAIL_TOKEN_PATH env vars, or pass them in config."
-      );
-    }
-    const { google: google2 } = _require16("googleapis");
-    const fs = await import("fs");
-    const creds = JSON.parse(fs.readFileSync(credPath, "utf-8"));
-    const token = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
-    const { client_id, client_secret, redirect_uris } = creds.installed || creds.web;
-    const oAuth2 = new google2.auth.OAuth2(
-      client_id,
-      client_secret,
-      redirect_uris?.[0]
-    );
-    oAuth2.setCredentials(token);
-    this.gmail = google2.gmail({ version: "v1", auth: oAuth2 });
-    return this.gmail;
-  }
-  getTools() {
-    const self = this;
-    return [
-      {
-        name: "gmail_send",
-        description: "Send an email via Gmail. Provide recipient, subject, and body.",
-        parameters: z4.object({
-          to: z4.string().describe("Recipient email address"),
-          subject: z4.string().describe("Email subject line"),
-          body: z4.string().describe("Email body (plain text)")
-        }),
-        execute: async (args, _ctx) => {
-          const gmail = await self.getGmailClient();
-          const rawMessage = [
-            `To: ${args.to}`,
-            `Subject: ${args.subject}`,
-            "Content-Type: text/plain; charset=utf-8",
-            "",
-            args.body
-          ].join("\n");
-          const encoded = Buffer.from(rawMessage).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-          const res = await gmail.users.messages.send({
-            userId: "me",
-            requestBody: { raw: encoded }
-          });
-          return `Email sent successfully. Message ID: ${res.data.id}`;
-        }
-      },
-      {
-        name: "gmail_search",
-        description: "Search emails in Gmail. Returns subject, from, date, and snippet for matching messages.",
-        parameters: z4.object({
-          query: z4.string().describe(
-            'Gmail search query (e.g. "from:john subject:meeting is:unread")'
-          ),
-          maxResults: z4.number().optional().describe("Maximum number of results (default 10)")
-        }),
-        execute: async (args, _ctx) => {
-          const gmail = await self.getGmailClient();
-          const max = args.maxResults ?? 10;
-          const list = await gmail.users.messages.list({
-            userId: "me",
-            q: args.query,
-            maxResults: max
-          });
-          const messages = list.data.messages ?? [];
-          if (messages.length === 0) return "No emails found.";
-          const results = [];
-          for (const msg of messages) {
-            const detail = await gmail.users.messages.get({
-              userId: "me",
-              id: msg.id,
-              format: "metadata",
-              metadataHeaders: ["From", "Subject", "Date"]
-            });
-            const headers = detail.data.payload?.headers ?? [];
-            const getHeader = (name) => headers.find(
-              (h) => h.name.toLowerCase() === name.toLowerCase()
-            )?.value ?? "";
-            results.push(
-              `ID: ${msg.id}
-From: ${getHeader("From")}
-Subject: ${getHeader("Subject")}
-Date: ${getHeader("Date")}
-Snippet: ${detail.data.snippet ?? ""}`
-            );
-          }
-          return results.join("\n\n---\n\n");
-        }
-      },
-      {
-        name: "gmail_read",
-        description: "Read the full content of an email by its message ID.",
-        parameters: z4.object({
-          messageId: z4.string().describe("The Gmail message ID to read")
-        }),
-        execute: async (args, _ctx) => {
-          const gmail = await self.getGmailClient();
-          const detail = await gmail.users.messages.get({
-            userId: "me",
-            id: args.messageId,
-            format: "full"
-          });
-          const headers = detail.data.payload?.headers ?? [];
-          const getHeader = (name) => headers.find(
-            (h) => h.name.toLowerCase() === name.toLowerCase()
-          )?.value ?? "";
-          let body = "";
-          const payload = detail.data.payload;
-          if (payload?.body?.data) {
-            body = Buffer.from(payload.body.data, "base64").toString("utf-8");
-          } else if (payload?.parts) {
-            const textPart = payload.parts.find(
-              (p) => p.mimeType === "text/plain"
-            );
-            if (textPart?.body?.data) {
-              body = Buffer.from(textPart.body.data, "base64").toString(
-                "utf-8"
-              );
-            } else {
-              const htmlPart = payload.parts.find(
-                (p) => p.mimeType === "text/html"
-              );
-              if (htmlPart?.body?.data) {
-                body = Buffer.from(htmlPart.body.data, "base64").toString(
-                  "utf-8"
-                );
-              }
-            }
-          }
-          return `From: ${getHeader("From")}
-To: ${getHeader("To")}
-Subject: ${getHeader("Subject")}
-Date: ${getHeader("Date")}
-
-${body || "(no body)"}`;
-        }
-      }
-    ];
-  }
-};
-
-// src/toolkits/whatsapp.ts
-import { z as z5 } from "zod";
-var WhatsAppToolkit = class extends Toolkit {
-  name = "whatsapp";
-  accessToken;
-  phoneNumberId;
-  version;
-  recipientWaid;
-  constructor(config = {}) {
-    super();
-    this.accessToken = config.accessToken ?? process.env.WHATSAPP_ACCESS_TOKEN ?? "";
-    this.phoneNumberId = config.phoneNumberId ?? process.env.WHATSAPP_PHONE_NUMBER_ID ?? "";
-    this.version = config.version ?? process.env.WHATSAPP_VERSION ?? "v22.0";
-    this.recipientWaid = config.recipientWaid ?? process.env.WHATSAPP_RECIPIENT_WAID;
-  }
-  getBaseUrl() {
-    return `https://graph.facebook.com/${this.version}/${this.phoneNumberId}/messages`;
-  }
-  validate() {
-    if (!this.accessToken) {
-      throw new Error(
-        "WhatsAppToolkit: accessToken is required. Set WHATSAPP_ACCESS_TOKEN env var or pass in config."
-      );
-    }
-    if (!this.phoneNumberId) {
-      throw new Error(
-        "WhatsAppToolkit: phoneNumberId is required. Set WHATSAPP_PHONE_NUMBER_ID env var or pass in config."
-      );
-    }
-  }
-  resolveRecipient(recipient) {
-    const r = recipient ?? this.recipientWaid;
-    if (!r) {
-      throw new Error(
-        "WhatsAppToolkit: recipient is required. Provide it in the tool call or set WHATSAPP_RECIPIENT_WAID env var."
-      );
-    }
-    return r.replace(/[^0-9]/g, "");
-  }
-  getTools() {
-    const self = this;
-    return [
-      {
-        name: "whatsapp_send_text",
-        description: "Send a text message to a WhatsApp user via WhatsApp Business Cloud API.",
-        parameters: z5.object({
-          text: z5.string().describe("The text message to send"),
-          recipient: z5.string().optional().describe(
-            "Recipient WhatsApp number with country code (e.g. 919876543210). Uses default if omitted."
-          ),
-          previewUrl: z5.boolean().optional().describe("Enable URL previews in the message (default false)")
-        }),
-        execute: async (args, _ctx) => {
-          self.validate();
-          const recipient = self.resolveRecipient(args.recipient);
-          const res = await fetch(self.getBaseUrl(), {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${self.accessToken}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              messaging_product: "whatsapp",
-              recipient_type: "individual",
-              to: recipient,
-              type: "text",
-              text: {
-                preview_url: args.previewUrl ?? false,
-                body: args.text
-              }
-            })
-          });
-          if (!res.ok) {
-            const err = await res.text();
-            throw new Error(
-              `WhatsApp send failed: ${res.status} ${err}`
-            );
-          }
-          const data = await res.json();
-          const msgId = data.messages?.[0]?.id ?? "unknown";
-          return `Message sent successfully to ${recipient}. Message ID: ${msgId}`;
-        }
-      },
-      {
-        name: "whatsapp_send_template",
-        description: "Send a template message to a WhatsApp user. Required for first-time outreach (24-hour messaging window).",
-        parameters: z5.object({
-          templateName: z5.string().describe(
-            'The pre-approved template name (e.g. "hello_world")'
-          ),
-          recipient: z5.string().optional().describe(
-            "Recipient WhatsApp number with country code. Uses default if omitted."
-          ),
-          languageCode: z5.string().optional().describe('Template language code (default "en_US")'),
-          components: z5.array(z5.record(z5.any())).optional().describe(
-            "Template components for dynamic content (header, body, button parameters)"
-          )
-        }),
-        execute: async (args, _ctx) => {
-          self.validate();
-          const recipient = self.resolveRecipient(args.recipient);
-          const langCode = args.languageCode ?? "en_US";
-          const template = {
-            name: args.templateName,
-            language: { code: langCode }
-          };
-          if (args.components) {
-            template.components = args.components;
-          }
-          const res = await fetch(self.getBaseUrl(), {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${self.accessToken}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              messaging_product: "whatsapp",
-              recipient_type: "individual",
-              to: recipient,
-              type: "template",
-              template
-            })
-          });
-          if (!res.ok) {
-            const err = await res.text();
-            throw new Error(
-              `WhatsApp template send failed: ${res.status} ${err}`
-            );
-          }
-          const data = await res.json();
-          const msgId = data.messages?.[0]?.id ?? "unknown";
-          return `Template message "${args.templateName}" sent to ${recipient}. Message ID: ${msgId}`;
-        }
-      }
-    ];
-  }
-};
-
-// src/toolkits/hackernews.ts
-import { z as z6 } from "zod";
-var HackerNewsToolkit = class extends Toolkit {
-  name = "hackernews";
-  config;
-  constructor(config = {}) {
-    super();
-    this.config = {
-      enableGetTopStories: config.enableGetTopStories ?? true,
-      enableGetUserDetails: config.enableGetUserDetails ?? true
-    };
-  }
-  getTools() {
-    const tools = [];
-    if (this.config.enableGetTopStories) {
-      tools.push({
-        name: "hackernews_top_stories",
-        description: "Get the top stories from Hacker News. Returns title, URL, score, author, and comment count.",
-        parameters: z6.object({
-          numStories: z6.number().optional().describe("Number of top stories to fetch (default 10, max 30)")
-        }),
-        execute: async (args, _ctx) => {
-          const num = Math.min(args.numStories ?? 10, 30);
-          const idsRes = await fetch(
-            "https://hacker-news.firebaseio.com/v0/topstories.json"
-          );
-          if (!idsRes.ok) throw new Error(`HN API failed: ${idsRes.status}`);
-          const ids = await idsRes.json();
-          const stories = await Promise.all(
-            ids.slice(0, num).map(async (id) => {
-              const res = await fetch(
-                `https://hacker-news.firebaseio.com/v0/item/${id}.json`
-              );
-              return res.json();
-            })
-          );
-          return stories.map(
-            (s, i) => `${i + 1}. ${s.title}
-   URL: ${s.url ?? `https://news.ycombinator.com/item?id=${s.id}`}
-   Score: ${s.score} | By: ${s.by} | Comments: ${s.descendants ?? 0}`
-          ).join("\n\n");
-        }
-      });
-    }
-    if (this.config.enableGetUserDetails) {
-      tools.push({
-        name: "hackernews_user",
-        description: "Get details about a Hacker News user by username. Returns karma, about, and account creation date.",
-        parameters: z6.object({
-          username: z6.string().describe("The HN username to look up")
-        }),
-        execute: async (args, _ctx) => {
-          const username = args.username;
-          const res = await fetch(
-            `https://hacker-news.firebaseio.com/v0/user/${username}.json`
-          );
-          if (!res.ok)
-            throw new Error(`HN user API failed: ${res.status}`);
-          const user = await res.json();
-          if (!user) return `User "${username}" not found.`;
-          const created = new Date(user.created * 1e3).toISOString().split("T")[0];
-          return [
-            `Username: ${user.id}`,
-            `Karma: ${user.karma}`,
-            `Created: ${created}`,
-            user.about ? `About: ${user.about}` : null,
-            `Submitted: ${user.submitted?.length ?? 0} items`
-          ].filter(Boolean).join("\n");
-        }
-      });
-    }
-    return tools;
-  }
-};
-export {
-  A2ARemoteAgent,
-  Agent,
-  AnthropicProvider,
-  BaseVectorStore,
-  EventBus,
-  GmailToolkit,
-  GoogleEmbedding,
-  GoogleProvider,
-  HackerNewsToolkit,
-  InMemoryStorage,
-  InMemoryVectorStore,
-  KnowledgeBase,
-  LLMLoop,
-  Logger,
-  MCPToolProvider,
-  Memory,
-  ModelRegistry,
-  MongoDBStorage,
-  MongoDBVectorStore,
-  OllamaProvider,
-  OpenAIEmbedding,
-  OpenAIProvider,
-  PgVectorStore,
-  PostgresStorage,
-  QdrantVectorStore,
-  RunContext,
-  SessionManager,
-  SqliteStorage,
-  Team,
-  TeamMode,
-  ToolExecutor,
-  Toolkit,
-  VertexAIProvider,
-  WebSearchToolkit,
-  WhatsAppToolkit,
-  Workflow,
-  anthropic,
-  defineTool,
-  getTextContent,
-  google,
-  isMultiModal,
-  ollama,
-  openai,
-  registry,
-  vertex
-};