@radaros/core 0.1.0

package/dist/index.js

@@ -0,0 +1,3462 @@
+// 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()) {
+      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/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);
+}
+
+// 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 createRequire7 } from "module";
+var _require7 = createRequire7(import.meta.url);
+var SqliteStorage = class {
+  db;
+  constructor(dbPath) {
+    try {
+      const Database = _require7("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 createRequire8 } from "module";
+var _require8 = createRequire8(import.meta.url);
+var PostgresStorage = class {
+  pool;
+  constructor(connectionString) {
+    try {
+      const { Pool } = _require8("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 createRequire9 } from "module";
+var _require9 = createRequire9(import.meta.url);
+var MongoDBStorage = class {
+  constructor(uri, dbName = "radaros", collectionName = "kv_store") {
+    this.uri = uri;
+    this.dbName = dbName;
+    this.collectionName = collectionName;
+    try {
+      const { MongoClient } = _require9("mongodb");
+      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 createRequire10 } from "module";
+var _require10 = createRequire10(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 } = _require10("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 createRequire11 } from "module";
+import { createHash } from "crypto";
+var _require11 = createRequire11(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 } = _require11("@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 createRequire12 } from "module";
+var _require12 = createRequire12(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 } = _require12("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 createRequire13 } from "module";
+var _require13 = createRequire13(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 = _require13("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 createRequire14 } from "module";
+var _require14 = createRequire14(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 } = _require14("@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);
+  }
+};
+export {
+  Agent,
+  AnthropicProvider,
+  BaseVectorStore,
+  EventBus,
+  GoogleEmbedding,
+  GoogleProvider,
+  InMemoryStorage,
+  InMemoryVectorStore,
+  KnowledgeBase,
+  LLMLoop,
+  Logger,
+  Memory,
+  ModelRegistry,
+  MongoDBStorage,
+  MongoDBVectorStore,
+  OllamaProvider,
+  OpenAIEmbedding,
+  OpenAIProvider,
+  PgVectorStore,
+  PostgresStorage,
+  QdrantVectorStore,
+  RunContext,
+  SessionManager,
+  SqliteStorage,
+  Team,
+  TeamMode,
+  ToolExecutor,
+  Workflow,
+  anthropic,
+  defineTool,
+  getTextContent,
+  google,
+  isMultiModal,
+  ollama,
+  openai,
+  registry
+};