@voltx/ai 0.3.0

package/dist/index.js

@@ -0,0 +1,925 @@
+// src/providers/registry.ts
+var providers = /* @__PURE__ */ new Map();
+function registerProvider(name, factory) {
+  providers.set(name, factory);
+}
+function getProvider(name, config = {}) {
+  const factory = providers.get(name);
+  if (!factory) {
+    const available = Array.from(providers.keys()).join(", ");
+    throw new Error(
+      `[voltx/ai] Unknown provider "${name}". Available: ${available}`
+    );
+  }
+  return factory(config);
+}
+function resolveModel(model) {
+  if (typeof model !== "string") return model;
+  const colonIndex = model.indexOf(":");
+  if (colonIndex === -1) {
+    return { provider: "openai", model, config: {} };
+  }
+  const provider = model.slice(0, colonIndex);
+  const modelName = model.slice(colonIndex + 1);
+  return { provider, model: modelName, config: {} };
+}
+var ENV_KEY_MAP = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  google: "GOOGLE_AI_API_KEY",
+  cerebras: "CEREBRAS_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  ollama: ""
+  // no key needed
+};
+function resolveApiKey(provider, explicit) {
+  if (explicit) return explicit;
+  const envKey = ENV_KEY_MAP[provider];
+  if (!envKey) return void 0;
+  return process.env[envKey];
+}
+
+// src/utils.ts
+function toProviderMessages(messages, system, prompt) {
+  const result = [];
+  if (system) {
+    result.push({ role: "system", content: system });
+  }
+  if (messages) {
+    for (const msg of messages) {
+      let content;
+      if (typeof msg.content === "string") {
+        content = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        const hasNonText = msg.content.some((p) => p.type !== "text");
+        if (hasNonText) {
+          result.push({
+            role: msg.role,
+            content: msg.content,
+            tool_calls: msg.tool_calls,
+            tool_call_id: msg.tool_call_id
+          });
+          continue;
+        }
+        content = msg.content.map((p) => p.type === "text" ? p.text : "").join("");
+      } else {
+        content = null;
+      }
+      result.push({
+        role: msg.role,
+        content,
+        tool_calls: msg.tool_calls,
+        tool_call_id: msg.tool_call_id
+      });
+    }
+  }
+  if (prompt) {
+    result.push({ role: "user", content: prompt });
+  }
+  return result;
+}
+function toProviderTools(tools) {
+  if (!tools) return void 0;
+  const entries = Object.entries(tools);
+  if (entries.length === 0) return void 0;
+  return entries.map(([key, tool]) => ({
+    type: "function",
+    function: {
+      name: tool.name ?? key,
+      description: tool.description,
+      parameters: isZodType(tool.parameters) ? zodToJsonSchema(tool.parameters) : tool.parameters
+    }
+  }));
+}
+function isZodType(value) {
+  return value !== null && typeof value === "object" && "_def" in value;
+}
+function zodToJsonSchema(schema) {
+  const def = schema._def;
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodObject": {
+      const shape = def.shape;
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape())) {
+        properties[key] = zodToJsonSchema(value);
+        const innerDef = value._def;
+        if (innerDef.typeName !== "ZodOptional") {
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        required: Object.keys(properties),
+        // strict mode requires ALL properties in required
+        additionalProperties: false
+      };
+    }
+    case "ZodString":
+      return { type: "string", ...def.description ? { description: def.description } : {} };
+    case "ZodNumber":
+      return { type: "number" };
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodArray":
+      return { type: "array", items: zodToJsonSchema(def.type) };
+    case "ZodEnum":
+      return { type: "string", enum: def.values };
+    case "ZodOptional":
+      return zodToJsonSchema(def.innerType);
+    case "ZodDefault":
+      return zodToJsonSchema(def.innerType);
+    default:
+      return { type: "string" };
+  }
+}
+
+// src/generate-text.ts
+async function generateText(options) {
+  const ref = resolveModel(options.model);
+  const apiKey = resolveApiKey(ref.provider, ref.config.apiKey);
+  const provider = getProvider(ref.provider, { ...ref.config, apiKey });
+  const messages = toProviderMessages(options.messages, options.system, options.prompt);
+  const tools = toProviderTools(options.tools);
+  const response = await provider.chat({
+    model: ref.model,
+    messages,
+    tools,
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    topP: options.topP,
+    stop: options.stop,
+    signal: options.signal
+  });
+  const toolCalls = response.toolCalls.map((tc) => {
+    let args = {};
+    try {
+      args = JSON.parse(tc.function.arguments);
+    } catch {
+      args = { _raw: tc.function.arguments };
+    }
+    return {
+      id: tc.id,
+      name: tc.function.name,
+      args
+    };
+  });
+  return {
+    text: response.text ?? "",
+    toolCalls,
+    usage: response.usage,
+    finishReason: response.finishReason,
+    raw: response.raw
+  };
+}
+
+// src/stream-text.ts
+async function streamText(options) {
+  const ref = resolveModel(options.model);
+  const apiKey = resolveApiKey(ref.provider, ref.config.apiKey);
+  const provider = getProvider(ref.provider, { ...ref.config, apiKey });
+  const messages = toProviderMessages(options.messages, options.system, options.prompt);
+  const tools = toProviderTools(options.tools);
+  const abortController = new AbortController();
+  const signal = options.signal ?? abortController.signal;
+  const response = await provider.stream({
+    model: ref.model,
+    messages,
+    tools,
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    topP: options.topP,
+    stop: options.stop,
+    signal
+  });
+  let fullText = "";
+  let finalUsage = null;
+  let consumed = false;
+  let resolveText;
+  let resolveUsage;
+  const textPromise = new Promise((resolve) => {
+    resolveText = resolve;
+  });
+  const usagePromise = new Promise((resolve) => {
+    resolveUsage = resolve;
+  });
+  const buffer = [];
+  async function* driveStream() {
+    if (consumed) {
+      for (const chunk of buffer) yield chunk;
+      return;
+    }
+    consumed = true;
+    try {
+      for await (const chunk of response.stream) {
+        if (chunk.type === "text-delta" && chunk.textDelta) {
+          fullText += chunk.textDelta;
+          buffer.push(chunk.textDelta);
+          yield chunk.textDelta;
+        }
+        if (chunk.type === "finish" && chunk.usage) {
+          finalUsage = chunk.usage;
+        }
+      }
+    } finally {
+      resolveText(fullText);
+      resolveUsage(finalUsage ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 });
+    }
+  }
+  return {
+    textStream: driveStream(),
+    text: textPromise,
+    usage: usagePromise,
+    abort() {
+      abortController.abort();
+    },
+    toSSEResponse() {
+      const encoder = new TextEncoder();
+      const source = consumed ? buffer : null;
+      const readable = new ReadableStream({
+        async start(controller) {
+          try {
+            if (source) {
+              for (const chunk of source) {
+                const data = JSON.stringify({ type: "text-delta", textDelta: chunk });
+                controller.enqueue(encoder.encode(`data: ${data}
+
+`));
+              }
+            } else {
+              for await (const chunk of driveStream()) {
+                const data = JSON.stringify({ type: "text-delta", textDelta: chunk });
+                controller.enqueue(encoder.encode(`data: ${data}
+
+`));
+              }
+            }
+            controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : "Unknown error";
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: "error", error: msg })}
+
+`));
+          } finally {
+            controller.close();
+          }
+        }
+      });
+      return new Response(readable, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive"
+        }
+      });
+    },
+    toReadableStream() {
+      const encoder = new TextEncoder();
+      return new ReadableStream({
+        async start(controller) {
+          try {
+            for await (const chunk of driveStream()) {
+              controller.enqueue(encoder.encode(chunk));
+            }
+          } finally {
+            controller.close();
+          }
+        }
+      });
+    }
+  };
+}
+
+// src/generate-object.ts
+async function generateObject(options) {
+  const ref = resolveModel(options.model);
+  const apiKey = resolveApiKey(ref.provider, ref.config.apiKey);
+  const provider = getProvider(ref.provider, { ...ref.config, apiKey });
+  const messages = toProviderMessages(options.messages, options.system, options.prompt);
+  const jsonSchema = zodToJsonSchema(options.schema);
+  const systemMsg = messages.find((m) => m.role === "system");
+  const jsonInstruction = `
+
+Respond with a valid JSON object matching this schema:
+${JSON.stringify(jsonSchema, null, 2)}`;
+  if (systemMsg) {
+    systemMsg.content = (systemMsg.content ?? "") + jsonInstruction;
+  } else {
+    messages.unshift({ role: "system", content: jsonInstruction });
+  }
+  const responseFormat = ref.provider === "anthropic" || ref.provider === "ollama" ? void 0 : {
+    type: "json_schema",
+    json_schema: {
+      name: options.schemaName ?? "response",
+      strict: true,
+      schema: jsonSchema
+    }
+  };
+  const response = await provider.chat({
+    model: ref.model,
+    messages,
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    responseFormat,
+    signal: options.signal
+  });
+  const text = response.text ?? "";
+  let parsed;
+  try {
+    const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/) ?? [null, text];
+    parsed = JSON.parse(jsonMatch[1].trim());
+  } catch {
+    throw new Error(
+      `[voltx/ai] Failed to parse JSON from model response. Raw text: ${text.slice(0, 200)}`
+    );
+  }
+  const validated = options.schema.safeParse(parsed);
+  if (!validated.success) {
+    throw new Error(
+      `[voltx/ai] Schema validation failed: ${validated.error.message}`
+    );
+  }
+  return {
+    object: validated.data,
+    usage: response.usage,
+    raw: response.raw
+  };
+}
+
+// src/embed.ts
+async function embed(options) {
+  const ref = resolveModel(options.model);
+  const apiKey = resolveApiKey(ref.provider, ref.config.apiKey);
+  const provider = getProvider(ref.provider, { ...ref.config, apiKey });
+  if (!provider.embed) {
+    throw new Error(
+      `[voltx/ai] Provider "${ref.provider}" does not support embeddings. Use openai, google, or ollama.`
+    );
+  }
+  const response = await provider.embed({
+    model: ref.model,
+    input: options.value
+  });
+  return {
+    embedding: response.embeddings[0],
+    usage: response.usage
+  };
+}
+async function embedMany(options) {
+  const ref = resolveModel(options.model);
+  const apiKey = resolveApiKey(ref.provider, ref.config.apiKey);
+  const provider = getProvider(ref.provider, { ...ref.config, apiKey });
+  if (!provider.embed) {
+    throw new Error(
+      `[voltx/ai] Provider "${ref.provider}" does not support embeddings. Use openai, google, or ollama.`
+    );
+  }
+  const response = await provider.embed({
+    model: ref.model,
+    input: options.values
+  });
+  return {
+    embeddings: response.embeddings,
+    usage: response.usage
+  };
+}
+
+// src/providers/openai-compatible.ts
+function createOpenAICompatibleProvider(cfg) {
+  const baseUrl = (cfg.baseUrl ?? cfg.defaultBaseUrl).replace(/\/$/, "");
+  function buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      ...cfg.headers
+    };
+    if (cfg.apiKey) {
+      headers["Authorization"] = `Bearer ${cfg.apiKey}`;
+    }
+    return headers;
+  }
+  function buildBody(options, stream = false) {
+    const body = {
+      model: options.model,
+      messages: options.messages,
+      stream
+    };
+    if (options.temperature !== void 0) body.temperature = options.temperature;
+    if (options.maxTokens !== void 0) body.max_tokens = options.maxTokens;
+    if (options.topP !== void 0) body.top_p = options.topP;
+    if (options.stop) body.stop = options.stop;
+    if (options.tools && options.tools.length > 0) body.tools = options.tools;
+    if (options.responseFormat && cfg.supportsJsonSchema !== false) {
+      body.response_format = options.responseFormat;
+    }
+    if (stream && cfg.supportsStreamOptions !== false) {
+      body.stream_options = { include_usage: true };
+    }
+    return body;
+  }
+  function mapFinishReason(reason) {
+    switch (reason) {
+      case "stop":
+        return "stop";
+      case "length":
+        return "length";
+      case "tool_calls":
+        return "tool_calls";
+      case "content_filter":
+        return "content_filter";
+      default:
+        return "unknown";
+    }
+  }
+  const provider = {
+    name: cfg.name,
+    async chat(options) {
+      const res = await fetch(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(buildBody(options, false)),
+        signal: options.signal
+      });
+      if (!res.ok) {
+        const errorBody = await res.text().catch(() => "Unknown error");
+        throw new Error(`[voltx/ai] ${cfg.name} API error (${res.status}): ${errorBody}`);
+      }
+      const data = await res.json();
+      const choices = data.choices;
+      const choice = choices?.[0] ?? {};
+      const message = choice.message ?? {};
+      const usage = data.usage ?? {};
+      return {
+        text: message.content ?? null,
+        toolCalls: message.tool_calls ?? [],
+        usage: {
+          promptTokens: usage.prompt_tokens ?? 0,
+          completionTokens: usage.completion_tokens ?? 0,
+          totalTokens: usage.total_tokens ?? 0
+        },
+        finishReason: mapFinishReason(choice.finish_reason),
+        raw: data
+      };
+    },
+    async stream(options) {
+      const res = await fetch(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(buildBody(options, true)),
+        signal: options.signal
+      });
+      if (!res.ok) {
+        const errorBody = await res.text().catch(() => "Unknown error");
+        throw new Error(`[voltx/ai] ${cfg.name} streaming error (${res.status}): ${errorBody}`);
+      }
+      const body = res.body;
+      if (!body) throw new Error(`[voltx/ai] ${cfg.name} returned no stream body`);
+      async function* parseSSEStream() {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const toolCallAccumulator = /* @__PURE__ */ new Map();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              const trimmed = line.trim();
+              if (!trimmed || !trimmed.startsWith("data: ")) continue;
+              const payload = trimmed.slice(6);
+              if (payload === "[DONE]") return;
+              try {
+                const chunk = JSON.parse(payload);
+                const choices = chunk.choices;
+                const delta = choices?.[0]?.delta;
+                const finishReason = choices?.[0]?.finish_reason;
+                if (delta?.content) {
+                  yield { type: "text-delta", textDelta: delta.content };
+                }
+                if (delta?.tool_calls) {
+                  const tcArray = delta.tool_calls;
+                  for (const tc of tcArray) {
+                    const index = tc.index ?? 0;
+                    const fn = tc.function;
+                    if (!toolCallAccumulator.has(index)) {
+                      toolCallAccumulator.set(index, { id: tc.id ?? "", name: fn?.name ?? "", arguments: "" });
+                    }
+                    const acc = toolCallAccumulator.get(index);
+                    if (tc.id) acc.id = tc.id;
+                    if (fn?.name) acc.name = fn.name;
+                    if (fn?.arguments) acc.arguments += fn.arguments;
+                  }
+                }
+                const usage = chunk.usage;
+                if (finishReason) {
+                  if (finishReason === "tool_calls") {
+                    for (const [, tc] of toolCallAccumulator) {
+                      yield {
+                        type: "tool-call-delta",
+                        toolCallDelta: {
+                          id: tc.id,
+                          type: "function",
+                          function: { name: tc.name, arguments: tc.arguments }
+                        }
+                      };
+                    }
+                  }
+                  yield {
+                    type: "finish",
+                    finishReason: mapFinishReason(finishReason),
+                    usage: usage ? {
+                      promptTokens: usage.prompt_tokens ?? 0,
+                      completionTokens: usage.completion_tokens ?? 0,
+                      totalTokens: usage.total_tokens ?? 0
+                    } : void 0
+                  };
+                }
+              } catch {
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+      return { stream: parseSSEStream() };
+    }
+  };
+  if (cfg.supportsEmbeddings) {
+    provider.embed = async (options) => {
+      const input = Array.isArray(options.input) ? options.input : [options.input];
+      const res = await fetch(`${baseUrl}/embeddings`, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify({ model: options.model, input })
+      });
+      if (!res.ok) {
+        const errorBody = await res.text().catch(() => "Unknown error");
+        throw new Error(`[voltx/ai] ${cfg.name} embeddings error (${res.status}): ${errorBody}`);
+      }
+      const data = await res.json();
+      const embeddings = data.data.map((d) => d.embedding);
+      const usage = data.usage ?? {};
+      return {
+        embeddings,
+        usage: { tokens: usage.total_tokens ?? usage.prompt_tokens ?? 0 }
+      };
+    };
+  }
+  return provider;
+}
+
+// src/providers/openai.ts
+function createOpenAIProvider(config = {}) {
+  return createOpenAICompatibleProvider({
+    ...config,
+    name: "openai",
+    apiKey: config.apiKey ?? resolveApiKey("openai"),
+    defaultBaseUrl: "https://api.openai.com/v1",
+    supportsEmbeddings: true,
+    supportsStreamOptions: true,
+    supportsJsonSchema: true
+  });
+}
+function openai(model) {
+  return { provider: "openai", model, config: {} };
+}
+
+// src/providers/anthropic.ts
+function createAnthropicProvider(config = {}) {
+  const apiKey = config.apiKey ?? resolveApiKey("anthropic");
+  const baseUrl = (config.baseUrl ?? "https://api.anthropic.com").replace(/\/$/, "");
+  function buildHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey ?? "",
+      "anthropic-version": "2023-06-01",
+      ...config.headers
+    };
+  }
+  function convertMessages(messages) {
+    let system;
+    const converted = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        system = system ? `${system}
+
+${msg.content ?? ""}` : msg.content ?? "";
+        continue;
+      }
+      if (msg.role === "tool") {
+        converted.push({
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: msg.tool_call_id,
+            content: msg.content ?? ""
+          }]
+        });
+        continue;
+      }
+      if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+        const content = [];
+        if (msg.content) content.push({ type: "text", text: msg.content });
+        for (const tc of msg.tool_calls) {
+          content.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments)
+          });
+        }
+        converted.push({ role: "assistant", content });
+        continue;
+      }
+      converted.push({
+        role: msg.role,
+        content: msg.content ?? ""
+      });
+    }
+    return { system, messages: converted };
+  }
+  function convertTools(tools) {
+    if (!tools || tools.length === 0) return void 0;
+    return tools.map((t) => ({
+      name: t.function.name,
+      description: t.function.description,
+      input_schema: t.function.parameters
+    }));
+  }
+  function mapStopReason(reason) {
+    switch (reason) {
+      case "end_turn":
+        return "stop";
+      case "max_tokens":
+        return "length";
+      case "tool_use":
+        return "tool_calls";
+      default:
+        return "unknown";
+    }
+  }
+  return {
+    name: "anthropic",
+    async chat(options) {
+      const { system, messages } = convertMessages(options.messages);
+      const body = {
+        model: options.model,
+        messages,
+        max_tokens: options.maxTokens ?? 4096
+      };
+      if (system) body.system = system;
+      if (options.temperature !== void 0) body.temperature = options.temperature;
+      if (options.topP !== void 0) body.top_p = options.topP;
+      if (options.stop) body.stop_sequences = options.stop;
+      const tools = convertTools(options.tools);
+      if (tools) body.tools = tools;
+      const res = await fetch(`${baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(body),
+        signal: options.signal
+      });
+      if (!res.ok) {
+        const errorBody = await res.text().catch(() => "Unknown error");
+        throw new Error(`[voltx/ai] Anthropic API error (${res.status}): ${errorBody}`);
+      }
+      const data = await res.json();
+      const content = data.content;
+      const usage = data.usage ?? {};
+      let text = "";
+      const toolCalls = [];
+      for (const block of content) {
+        if (block.type === "text") {
+          text += block.text;
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            type: "function",
+            function: {
+              name: block.name,
+              arguments: JSON.stringify(block.input)
+            }
+          });
+        }
+      }
+      return {
+        text: text || null,
+        toolCalls,
+        usage: {
+          promptTokens: usage.input_tokens ?? 0,
+          completionTokens: usage.output_tokens ?? 0,
+          totalTokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0)
+        },
+        finishReason: mapStopReason(data.stop_reason),
+        raw: data
+      };
+    },
+    async stream(options) {
+      const { system, messages } = convertMessages(options.messages);
+      const body = {
+        model: options.model,
+        messages,
+        max_tokens: options.maxTokens ?? 4096,
+        stream: true
+      };
+      if (system) body.system = system;
+      if (options.temperature !== void 0) body.temperature = options.temperature;
+      if (options.topP !== void 0) body.top_p = options.topP;
+      if (options.stop) body.stop_sequences = options.stop;
+      const tools = convertTools(options.tools);
+      if (tools) body.tools = tools;
+      const res = await fetch(`${baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(body),
+        signal: options.signal
+      });
+      if (!res.ok) {
+        const errorBody = await res.text().catch(() => "Unknown error");
+        throw new Error(`[voltx/ai] Anthropic streaming error (${res.status}): ${errorBody}`);
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      async function* parseStream() {
+        let buffer = "";
+        let currentToolId = "";
+        let currentToolName = "";
+        let currentToolArgs = "";
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              const trimmed = line.trim();
+              if (!trimmed.startsWith("data: ")) continue;
+              const payload = trimmed.slice(6);
+              try {
+                const event = JSON.parse(payload);
+                const type = event.type;
+                if (type === "content_block_start") {
+                  const contentBlock = event.content_block;
+                  if (contentBlock?.type === "tool_use") {
+                    currentToolId = contentBlock.id;
+                    currentToolName = contentBlock.name;
+                    currentToolArgs = "";
+                  }
+                } else if (type === "content_block_delta") {
+                  const delta = event.delta;
+                  if (delta.type === "text_delta") {
+                    yield { type: "text-delta", textDelta: delta.text };
+                  } else if (delta.type === "input_json_delta") {
+                    currentToolArgs += delta.partial_json ?? "";
+                  }
+                } else if (type === "content_block_stop") {
+                  if (currentToolId) {
+                    yield {
+                      type: "tool-call-delta",
+                      toolCallDelta: {
+                        id: currentToolId,
+                        type: "function",
+                        function: { name: currentToolName, arguments: currentToolArgs }
+                      }
+                    };
+                    currentToolId = "";
+                    currentToolName = "";
+                    currentToolArgs = "";
+                  }
+                } else if (type === "message_delta") {
+                  const delta = event.delta;
+                  const usage = event.usage;
+                  yield {
+                    type: "finish",
+                    finishReason: mapStopReason(delta.stop_reason),
+                    usage: usage ? {
+                      promptTokens: usage.input_tokens ?? 0,
+                      completionTokens: usage.output_tokens ?? 0,
+                      totalTokens: (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0)
+                    } : void 0
+                  };
+                }
+              } catch {
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+      return { stream: parseStream() };
+    }
+    // Anthropic does not support embeddings
+  };
+}
+function anthropic(model) {
+  return { provider: "anthropic", model, config: {} };
+}
+
+// src/providers/google.ts
+function createGoogleProvider(config = {}) {
+  const apiKey = config.apiKey ?? resolveApiKey("google");
+  return createOpenAICompatibleProvider({
+    ...config,
+    name: "google",
+    apiKey,
+    defaultBaseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+    supportsEmbeddings: true,
+    supportsStreamOptions: false,
+    supportsJsonSchema: true
+  });
+}
+function google(model) {
+  return { provider: "google", model, config: {} };
+}
+
+// src/providers/cerebras.ts
+function createCerebrasProvider(config = {}) {
+  return createOpenAICompatibleProvider({
+    ...config,
+    name: "cerebras",
+    apiKey: config.apiKey ?? resolveApiKey("cerebras"),
+    defaultBaseUrl: "https://api.cerebras.ai/v1",
+    supportsEmbeddings: false,
+    supportsStreamOptions: false,
+    supportsJsonSchema: true
+  });
+}
+function cerebras(model) {
+  return { provider: "cerebras", model, config: {} };
+}
+
+// src/providers/openrouter.ts
+function createOpenRouterProvider(config = {}) {
+  return createOpenAICompatibleProvider({
+    ...config,
+    name: "openrouter",
+    apiKey: config.apiKey ?? resolveApiKey("openrouter"),
+    defaultBaseUrl: "https://openrouter.ai/api/v1",
+    headers: {
+      "HTTP-Referer": "https://voltx.co.in",
+      "X-Title": "VoltX AI Framework",
+      ...config.headers
+    },
+    supportsEmbeddings: false,
+    supportsStreamOptions: true,
+    supportsJsonSchema: true
+  });
+}
+function openrouter(model) {
+  return { provider: "openrouter", model, config: {} };
+}
+
+// src/providers/ollama.ts
+function createOllamaProvider(config = {}) {
+  return createOpenAICompatibleProvider({
+    name: "ollama",
+    baseUrl: config.baseUrl,
+    headers: config.headers,
+    defaultBaseUrl: "http://localhost:11434/v1",
+    supportsEmbeddings: true,
+    supportsStreamOptions: false,
+    supportsJsonSchema: false
+  });
+}
+function ollama(model) {
+  return { provider: "ollama", model, config: {} };
+}
+
+// src/index.ts
+registerProvider("openai", createOpenAIProvider);
+registerProvider("anthropic", createAnthropicProvider);
+registerProvider("google", createGoogleProvider);
+registerProvider("cerebras", createCerebrasProvider);
+registerProvider("openrouter", createOpenRouterProvider);
+registerProvider("ollama", createOllamaProvider);
+var VERSION = "0.3.0";
+export {
+  VERSION,
+  anthropic,
+  cerebras,
+  createAnthropicProvider,
+  createCerebrasProvider,
+  createGoogleProvider,
+  createOllamaProvider,
+  createOpenAIProvider,
+  createOpenRouterProvider,
+  embed,
+  embedMany,
+  generateObject,
+  generateText,
+  getProvider,
+  google,
+  ollama,
+  openai,
+  openrouter,
+  registerProvider,
+  resolveModel,
+  streamText
+};