@threaded/ai 1.0.29 → 1.1.0

package/dist/index.js

@@ -1,2062 +1,18 @@
-// src/schema.ts
-import { z } from "zod";
-var isStandardSchema = (schema) => {
-  return schema && typeof schema === "object" && "~standard" in schema;
-};
-var convertStandardSchemaToJsonSchema = (standardSchema, name = "Schema") => {
-  const jsonSchema = z.toJSONSchema(standardSchema);
-  return {
-    name,
-    schema: jsonSchema
-  };
-};
-var convertMCPSchemaToToolSchema = (mcpSchema) => {
-  if (!mcpSchema?.properties) return {};
-  const convertProperty = (prop) => ({
-    type: prop.type || "string",
-    description: prop.description || "",
-    ...prop.enum && { enum: prop.enum },
-    ...prop.items && { items: convertProperty(prop.items) },
-    ...prop.properties && {
-      properties: Object.fromEntries(
-        Object.entries(prop.properties).map(([k, v]) => [k, convertProperty(v)])
-      )
-    }
-  });
-  const result = {};
-  for (const [key, value] of Object.entries(mcpSchema.properties)) {
-    const prop = value;
-    result[key] = {
-      ...convertProperty(prop),
-      optional: !mcpSchema.required?.includes(key)
-    };
-  }
-  return result;
-};
-function normalizeSchema(schema, name) {
-  if (isStandardSchema(schema)) {
-    return convertStandardSchemaToJsonSchema(schema, name);
-  }
-  return schema;
-}
-var convertStandardSchemaToSchemaProperties = (standardSchema) => {
-  const jsonSchema = z.toJSONSchema(standardSchema);
-  return convertMCPSchemaToToolSchema(jsonSchema);
-};
-
-// src/mcp.ts
-var createMCPTools = async (client) => {
-  const serverInfo = client.getServerVersion();
-  const serverName = serverInfo?.name;
-  if (!serverName) {
-    console.error("MCP server has no name? Skipping tool creation.");
-    return [];
-  }
-  const toolsResponse = await client.listTools();
-  return toolsResponse.tools.map((mcpTool) => {
-    const prefixedName = `${serverName}_${mcpTool.name}`;
-    return {
-      name: prefixedName,
-      description: `[${serverName}] ${mcpTool.description || ""}`,
-      schema: convertMCPSchemaToToolSchema(mcpTool.inputSchema),
-      execute: async (args) => {
-        const result = await client.callTool({
-          name: mcpTool.name,
-          arguments: args
-        });
-        return result.content && Array.isArray(result.content) && result.content[0]?.text || JSON.stringify(result);
-      }
-    };
-  });
-};
-
-// src/types.ts
-var Inherit = /* @__PURE__ */ ((Inherit2) => {
-  Inherit2[Inherit2["Nothing"] = 0] = "Nothing";
-  Inherit2[Inherit2["Conversation"] = 1] = "Conversation";
-  Inherit2[Inherit2["Tools"] = 2] = "Tools";
-  Inherit2[Inherit2["All"] = 3] = "All";
-  return Inherit2;
-})(Inherit || {});
-
-// src/utils.ts
-var toolConfigToToolDefinition = (tool) => {
-  const schema = isStandardSchema(tool.schema) ? convertStandardSchemaToSchemaProperties(tool.schema) : tool.schema;
-  const properties = {};
-  const required = [];
-  for (const [key, prop] of Object.entries(schema)) {
-    properties[key] = convertSchemaProperty(prop);
-    if (!prop.optional) {
-      required.push(key);
-    }
-  }
-  return {
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: {
-        type: "object",
-        properties,
-        ...required.length > 0 && { required }
-      }
-    }
-  };
-};
-var convertSchemaProperty = (prop) => {
-  const result = {
-    type: prop.type
-  };
-  if (prop.description) {
-    result.description = prop.description;
-  }
-  if (prop.enum) {
-    result.enum = prop.enum;
-  }
-  if (prop.items) {
-    result.items = convertSchemaProperty(prop.items);
-  }
-  if (prop.properties) {
-    result.properties = {};
-    for (const [key, childProp] of Object.entries(prop.properties)) {
-      result.properties[key] = convertSchemaProperty(childProp);
-    }
-  }
-  return result;
-};
-var parseModelName = (model2) => {
-  const parts = model2.split("/");
-  if (parts.length === 1) {
-    return { provider: "huggingface", model: parts[0] };
-  }
-  return {
-    provider: parts[0],
-    model: parts.slice(1).join("/")
-  };
-};
-var globalKeys = {};
-var setKeys = (keys) => {
-  globalKeys = { ...globalKeys, ...keys };
-};
-var getKey = (provider) => {
-  const key = globalKeys[provider.toLowerCase()];
-  if (!key) {
-    throw new Error(`No API key configured for provider: ${provider}`);
-  }
-  return key;
-};
-var maxCalls = (toolConfig, maxCalls2) => ({
-  ...toolConfig,
-  _maxCalls: maxCalls2
-});
-var addUsage = (existing, promptTokens, completionTokens, totalTokens) => ({
-  promptTokens: (existing?.promptTokens || 0) + promptTokens,
-  completionTokens: (existing?.completionTokens || 0) + completionTokens,
-  totalTokens: (existing?.totalTokens || 0) + totalTokens
-});
-
-// src/embed.ts
-var modelCache = /* @__PURE__ */ new Map();
-var embed = async (model2, text, config) => {
-  if (model2.startsWith("openai/")) {
-    const modelName = model2.replace("openai/", "");
-    const apiKey = getKey("openai") || process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-      throw new Error("OpenAI API key not found");
-    }
-    const body = {
-      model: modelName,
-      input: text
-    };
-    if (config?.dimensions) {
-      body.dimensions = config.dimensions;
-    }
-    const response = await fetch("https://api.openai.com/v1/embeddings", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`OpenAI API error: ${error}`);
-    }
-    const data = await response.json();
-    return data.data[0].embedding;
-  }
-  try {
-    const { pipeline } = await import("@huggingface/transformers");
-    if (!modelCache.has(model2)) {
-      const extractor2 = await pipeline("feature-extraction", model2, {
-        dtype: "fp32"
-      });
-      modelCache.set(model2, extractor2);
-    }
-    const extractor = modelCache.get(model2);
-    const result = await extractor(text, { pooling: "mean", normalize: true });
-    return Array.from(result.data);
-  } catch (error) {
-    throw new Error(
-      `huggingface transformers failed to load. install system dependencies or use openai models instead. original error: ${error.message}`
-    );
-  }
-};
-
-// src/image.ts
-var providerKeyEnvVars = {
-  openai: "OPENAI_API_KEY",
-  xai: "XAI_API_KEY",
-  google: "GEMINI_API_KEY"
-};
-var getApiKey = (provider) => {
-  try {
-    return getKey(provider);
-  } catch {
-    const envVar = providerKeyEnvVars[provider];
-    const key = envVar ? process.env[envVar] || "" : "";
-    if (!key) throw new Error(`No API key found for provider: ${provider}`);
-    return key;
-  }
-};
-var generateOpenAICompatible = async (endpoint, modelName, prompt, apiKey, config) => {
-  const isGptImage = modelName.startsWith("gpt-image");
-  const body = {
-    model: modelName,
-    prompt
-  };
-  if (!isGptImage) {
-    body.response_format = config?.responseFormat || "b64_json";
-  }
-  if (config?.n) body.n = config.n;
-  if (config?.size) body.size = config.size;
-  if (config?.quality) body.quality = config.quality;
-  if (config?.style && !isGptImage) body.style = config.style;
-  if (isGptImage) {
-    if (config?.outputFormat) body.output_format = config.outputFormat;
-    if (config?.outputCompression != null) body.output_compression = config.outputCompression;
-    if (config?.background) body.background = config.background;
-    if (config?.moderation) body.moderation = config.moderation;
-  }
-  const response = await fetch(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`API error: ${error}`);
-  }
-  const data = await response.json();
-  const image = data.data[0];
-  return {
-    data: image.b64_json || image.url,
-    revisedPrompt: image.revised_prompt
-  };
-};
-var generateGoogle = async (modelName, prompt, apiKey, config) => {
-  const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/${modelName}:generateContent`;
-  const body = {
-    contents: [{ parts: [{ text: prompt }] }],
-    generationConfig: {
-      responseModalities: ["TEXT", "IMAGE"]
-    }
-  };
-  const imageConfig = {};
-  if (config?.aspectRatio) imageConfig.aspectRatio = config.aspectRatio;
-  if (config?.imageSize) imageConfig.imageSize = config.imageSize;
-  if (Object.keys(imageConfig).length > 0) {
-    body.generationConfig.imageConfig = imageConfig;
-  }
-  const response = await fetch(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-goog-api-key": apiKey
-    },
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Google API error: ${error}`);
-  }
-  const data = await response.json();
-  const parts = data.candidates?.[0]?.content?.parts || [];
-  const imagePart = parts.find((p) => p.inlineData);
-  const textPart = parts.find((p) => p.text);
-  if (!imagePart?.inlineData?.data) {
-    throw new Error("No image data in response");
-  }
-  return {
-    data: imagePart.inlineData.data,
-    revisedPrompt: textPart?.text
-  };
-};
-var generateImage = async (model2, prompt, config) => {
-  const { provider, model: modelName } = parseModelName(model2);
-  const providerLower = provider.toLowerCase();
-  const apiKey = getApiKey(providerLower);
-  switch (providerLower) {
-    case "openai":
-      return generateOpenAICompatible(
-        "https://api.openai.com/v1/images/generations",
-        modelName,
-        prompt,
-        apiKey,
-        config
-      );
-    case "xai":
-      return generateOpenAICompatible(
-        "https://api.x.ai/v1/images/generations",
-        modelName,
-        prompt,
-        apiKey,
-        config
-      );
-    case "google":
-      return generateGoogle(modelName, prompt, apiKey, config);
-    default:
-      throw new Error(`Unsupported image generation provider: ${provider}`);
-  }
-};
-
-// src/image-model-schema.ts
-var IMAGE_MODEL_SCHEMA = {
-  openai: {
-    "dall-e-3": {
-      size: {
-        values: ["1024x1024", "1024x1792", "1792x1024"],
-        default: "1024x1024",
-        description: "Image dimensions"
-      },
-      quality: {
-        values: ["standard", "hd"],
-        default: "standard",
-        description: "Image quality level"
-      },
-      style: {
-        values: ["vivid", "natural"],
-        default: "vivid",
-        description: "Image style"
-      }
-    },
-    "gpt-image-1.5": {
-      size: {
-        values: ["1024x1024", "1536x1024", "1024x1536", "auto"],
-        default: "auto",
-        description: "Image dimensions"
-      },
-      quality: {
-        values: ["low", "medium", "high", "auto"],
-        default: "auto",
-        description: "Image quality level"
-      },
-      background: {
-        values: ["transparent", "opaque", "auto"],
-        default: "auto",
-        description: "Background type"
-      },
-      moderation: {
-        values: ["auto", "low"],
-        default: "auto",
-        description: "Content moderation level"
-      }
-    }
-  },
-  google: {
-    "gemini-2.5-flash-image": {
-      aspectRatio: {
-        values: ["1:1", "3:4", "4:3", "9:16", "16:9"],
-        default: "1:1",
-        description: "Image aspect ratio"
-      }
-    },
-    "gemini-3-pro-image-preview": {
-      aspectRatio: {
-        values: ["1:1", "3:4", "4:3", "9:16", "16:9"],
-        default: "1:1",
-        description: "Image aspect ratio"
-      },
-      imageSize: {
-        values: ["1K", "2K"],
-        default: "1K",
-        description: "Output image size"
-      }
-    }
-  },
-  xai: {}
-};
-var IMAGE_EDIT_MODEL_SCHEMA = {
-  openai: {
-    "gpt-image-1.5": {
-      size: {
-        values: ["1024x1024", "1536x1024", "1024x1536", "auto"],
-        default: "auto",
-        description: "Output image size"
-      },
-      quality: {
-        values: ["low", "medium", "high", "auto"],
-        default: "auto",
-        description: "Image quality level"
-      },
-      background: {
-        values: ["transparent", "opaque", "auto"],
-        default: "auto",
-        description: "Background type"
-      }
-    }
-  },
-  google: {
-    "gemini-3-pro-image-preview": {}
-  }
-};
-function getModelConfig(provider, model2) {
-  return IMAGE_MODEL_SCHEMA[provider]?.[model2] || null;
-}
-function getDefaultConfig(provider, model2) {
-  const schema = getModelConfig(provider, model2);
-  if (!schema) return {};
-  const defaults = {};
-  for (const [key, option] of Object.entries(schema)) {
-    defaults[key] = option.default;
-  }
-  return defaults;
-}
-
-// src/providers/openai.ts
-var getApiKey2 = (configApiKey) => {
-  if (configApiKey) return configApiKey;
-  try {
-    return getKey("openai");
-  } catch {
-    const key = process.env.OPENAI_API_KEY || "";
-    if (!key) throw new Error("OpenAI API key not found");
-    return key;
-  }
-};
-var appendToolCalls = (toolCalls, tcchunklist) => {
-  for (const tcchunk of tcchunklist) {
-    while (toolCalls.length <= tcchunk.index) {
-      toolCalls.push({
-        id: "",
-        type: "function",
-        function: { name: "", arguments: "" }
-      });
-    }
-    const tc = toolCalls[tcchunk.index];
-    tc.id += tcchunk.id || "";
-    tc.function.name += tcchunk.function?.name || "";
-    tc.function.arguments += tcchunk.function?.arguments || "";
-  }
-  return toolCalls;
-};
-var callOpenAI = async (config, ctx) => {
-  const { model: model2, instructions, schema, apiKey: configApiKey } = config;
-  const apiKey = getApiKey2(configApiKey);
-  const messages = [];
-  if (instructions) {
-    messages.push({ role: "system", content: instructions });
-  }
-  messages.push(...ctx.history);
-  const body = {
-    model: model2,
-    messages,
-    stream: !!ctx.stream,
-    ...ctx.stream && { stream_options: { include_usage: true } }
-  };
-  if (schema) {
-    body.response_format = {
-      type: "json_schema",
-      json_schema: {
-        name: schema.name,
-        schema: { ...schema.schema, additionalProperties: false },
-        strict: true
-      }
-    };
-  }
-  if (ctx.tools && ctx.tools.length > 0) {
-    body.tools = ctx.tools;
-    body.tool_choice = "auto";
-  }
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify(body),
-    signal: ctx.abortSignal
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`OpenAI API error: ${error}`);
-  }
-  if (ctx.stream) {
-    return handleOpenAIStream(response, ctx);
-  }
-  const data = await response.json();
-  const choice = data.choices[0];
-  const { message } = choice;
-  const msg = {
-    role: "assistant",
-    content: message.content || ""
-  };
-  if (message.tool_calls) {
-    msg.tool_calls = message.tool_calls;
-  }
-  return {
-    ...ctx,
-    lastResponse: msg,
-    history: [...ctx.history, msg],
-    usage: addUsage(ctx.usage, data.usage?.prompt_tokens || 0, data.usage?.completion_tokens || 0, data.usage?.total_tokens || 0)
-  };
-};
-var handleOpenAIStream = async (response, ctx) => {
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let fullContent = "";
-  let toolCalls = [];
-  let buffer = "";
-  let streamUsage = null;
-  try {
-    while (true) {
-      if (ctx.abortSignal?.aborted) {
-        break;
-      }
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data = line.slice(6).trim();
-          if (data === "[DONE]") continue;
-          if (!data) continue;
-          try {
-            const parsed = JSON.parse(data);
-            if (parsed.usage) {
-              streamUsage = parsed.usage;
-            }
-            const delta = parsed.choices?.[0]?.delta;
-            if (delta?.content) {
-              fullContent += delta.content;
-              if (ctx.stream) {
-                ctx.stream({ type: "content", content: delta.content });
-              }
-            }
-            if (delta?.tool_calls) {
-              toolCalls = appendToolCalls(toolCalls, delta.tool_calls);
-            }
-          } catch (e) {
-          }
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const msg = {
-    role: "assistant",
-    content: fullContent
-  };
-  if (toolCalls.length > 0) {
-    msg.tool_calls = toolCalls;
-  }
-  const usage = addUsage(ctx.usage, streamUsage?.prompt_tokens || 0, streamUsage?.completion_tokens || 0, streamUsage?.total_tokens || 0);
-  if (ctx.stream && streamUsage) {
-    ctx.stream({ type: "usage", usage });
-  }
-  return {
-    ...ctx,
-    lastResponse: msg,
-    history: [...ctx.history, msg],
-    usage
-  };
-};
-
-// src/providers/anthropic.ts
-var getApiKey3 = (configApiKey) => {
-  if (configApiKey) return configApiKey;
-  try {
-    return getKey("anthropic");
-  } catch {
-    const key = process.env.ANTHROPIC_API_KEY || "";
-    if (!key) throw new Error("Anthropic API key not found");
-    return key;
-  }
-};
-var convertToAnthropicFormat = (messages) => {
-  const result = [];
-  let i = 0;
-  while (i < messages.length) {
-    const msg = messages[i];
-    if (msg.role === "system") {
-      i++;
-      continue;
-    }
-    if (msg.role === "assistant") {
-      if (msg.tool_calls) {
-        result.push({
-          role: "assistant",
-          content: msg.tool_calls.map((tc) => ({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.function.name,
-            input: JSON.parse(tc.function.arguments)
-          }))
-        });
-      } else {
-        result.push({
-          role: "assistant",
-          content: msg.content
-        });
-      }
-      i++;
-    } else if (msg.role === "tool") {
-      const toolResults = [];
-      while (i < messages.length && messages[i].role === "tool") {
-        const toolMsg = messages[i];
-        toolResults.push({
-          type: "tool_result",
-          tool_use_id: toolMsg.tool_call_id,
-          content: toolMsg.content
-        });
-        i++;
-      }
-      result.push({
-        role: "user",
-        content: toolResults
-      });
-    } else {
-      result.push(msg);
-      i++;
-    }
-  }
-  return result;
-};
-var callAnthropic = async (config, ctx) => {
-  const { model: model2, instructions, schema, apiKey: configApiKey } = config;
-  const apiKey = getApiKey3(configApiKey);
-  let system = instructions;
-  if (ctx.history[0]?.role === "system") {
-    system = ctx.history[0].content;
-  }
-  const messages = convertToAnthropicFormat(ctx.history);
-  if (schema) {
-    const schemaPrompt = `
-
-You must respond with valid JSON that matches this schema:
-${JSON.stringify(
-      schema.schema,
-      null,
-      2
-    )}
-
-Return only the JSON object, no other text or formatting.`;
-    system = system ? system + schemaPrompt : schemaPrompt.slice(2);
-  }
-  const body = {
-    model: model2,
-    messages,
-    max_tokens: 4096,
-    stream: !!ctx.stream
-  };
-  if (system) {
-    body.system = system;
-  }
-  if (ctx.tools && ctx.tools.length > 0) {
-    body.tools = ctx.tools.map((tool) => ({
-      name: tool.function.name,
-      description: tool.function.description,
-      input_schema: tool.function.parameters
-    }));
-  }
-  const response = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-api-key": apiKey,
-      "anthropic-version": "2023-06-01"
-    },
-    body: JSON.stringify(body),
-    signal: ctx.abortSignal
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Anthropic API error: ${error}`);
-  }
-  if (ctx.stream) {
-    return handleAnthropicStream(response, ctx);
-  }
-  const data = await response.json();
-  const content = data.content[0];
-  const msg = {
-    role: "assistant",
-    content: content.type === "text" ? content.text : ""
-  };
-  if (content.type === "tool_use") {
-    msg.tool_calls = [
-      {
-        id: content.id,
-        type: "function",
-        function: {
-          name: content.name,
-          arguments: JSON.stringify(content.input)
-        }
-      }
-    ];
-  }
-  const inputTokens = data.usage?.input_tokens || 0;
-  const outputTokens = data.usage?.output_tokens || 0;
-  return {
-    ...ctx,
-    lastResponse: msg,
-    history: [...ctx.history, msg],
-    usage: addUsage(ctx.usage, inputTokens, outputTokens, inputTokens + outputTokens)
-  };
-};
-var handleAnthropicStream = async (response, ctx) => {
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let fullContent = "";
-  const toolCalls = [];
-  let buffer = "";
-  let inputTokens = 0;
-  let outputTokens = 0;
-  try {
-    while (true) {
-      if (ctx.abortSignal?.aborted) {
-        break;
-      }
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data = line.slice(6).trim();
-          if (!data) continue;
-          try {
-            const parsed = JSON.parse(data);
-            if (parsed.type === "message_start" && parsed.message?.usage) {
-              inputTokens = parsed.message.usage.input_tokens || 0;
-            }
-            if (parsed.type === "message_delta" && parsed.usage) {
-              outputTokens = parsed.usage.output_tokens || 0;
-            }
-            if (parsed.type === "content_block_delta" && parsed.delta?.text) {
-              fullContent += parsed.delta.text;
-              if (ctx.stream) {
-                ctx.stream({ type: "content", content: parsed.delta.text });
-              }
-            }
-            if (parsed.type === "content_block_start" && parsed.content_block?.type === "tool_use") {
-              const toolUse = parsed.content_block;
-              toolCalls.push({
-                id: toolUse.id,
-                type: "function",
-                function: {
-                  name: toolUse.name,
-                  arguments: ""
-                },
-                index: parsed.index
-              });
-            }
-            if (parsed.type === "content_block_delta" && parsed.delta?.type === "input_json_delta") {
-              const toolCall = toolCalls.find((tc) => tc.index === parsed.index);
-              if (toolCall) {
-                toolCall.function.arguments += parsed.delta.partial_json;
-              }
-            }
-          } catch (e) {
-          }
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const msg = {
-    role: "assistant",
-    content: fullContent
-  };
-  if (toolCalls.length > 0) {
-    msg.tool_calls = toolCalls.map(({ index, ...tc }) => tc);
-  }
-  const usage = addUsage(ctx.usage, inputTokens, outputTokens, inputTokens + outputTokens);
-  if (ctx.stream && (inputTokens || outputTokens)) {
-    ctx.stream({ type: "usage", usage });
-  }
-  return {
-    ...ctx,
-    lastResponse: msg,
-    history: [...ctx.history, msg],
-    usage
-  };
-};
-
-// src/providers/google.ts
-var getApiKey4 = (configApiKey) => {
-  if (configApiKey) return configApiKey;
-  try {
-    return getKey("google");
-  } catch {
-    const key = process.env.GEMINI_API_KEY || process.env.GOOGLE_AI_API_KEY || "";
-    if (!key) throw new Error("Google API key not found");
-    return key;
-  }
-};
-var callGoogle = async (config, ctx) => {
-  const { model: model2, instructions, apiKey: configApiKey } = config;
-  const apiKey = getApiKey4(configApiKey);
-  const contents = [];
-  if (instructions) {
-    contents.push({
-      role: "user",
-      parts: [{ text: instructions }]
-    });
-    contents.push({
-      role: "model",
-      parts: [{ text: "I understand." }]
-    });
-  }
-  const toolCallMap = /* @__PURE__ */ new Map();
-  for (let i = 0; i < ctx.history.length; i++) {
-    const msg2 = ctx.history[i];
-    if (msg2.role === "assistant") {
-      const parts2 = [];
-      if (msg2.content) {
-        parts2.push({ text: msg2.content });
-      }
-      if (msg2.tool_calls?.length) {
-        for (const tc of msg2.tool_calls) {
-          toolCallMap.set(tc.id, tc.function.name);
-          const part = {
-            functionCall: {
-              name: tc.function.name,
-              args: JSON.parse(tc.function.arguments)
-            }
-          };
-          if (tc.thoughtSignature) {
-            part.thoughtSignature = tc.thoughtSignature;
-          }
-          parts2.push(part);
-        }
-      }
-      if (parts2.length > 0) {
-        contents.push({ role: "model", parts: parts2 });
-      }
-    } else if (msg2.role === "tool") {
-      const responseParts = [];
-      while (i < ctx.history.length && ctx.history[i].role === "tool") {
-        const toolMsg = ctx.history[i];
-        const functionName = toolCallMap.get(toolMsg.tool_call_id);
-        if (functionName) {
-          let responseData;
-          try {
-            responseData = JSON.parse(toolMsg.content);
-          } catch {
-            responseData = { result: toolMsg.content };
-          }
-          if (Array.isArray(responseData)) {
-            responseData = { result: responseData };
-          }
-          responseParts.push({
-            functionResponse: {
-              name: functionName,
-              response: responseData
-            }
-          });
-        }
-        i++;
-      }
-      i--;
-      if (responseParts.length > 0) {
-        contents.push({ role: "user", parts: responseParts });
-      }
-    } else if (msg2.role === "user") {
-      contents.push({
-        role: "user",
-        parts: [{ text: msg2.content }]
-      });
-    }
-  }
-  const body = {
-    contents
-  };
-  if (ctx.tools && ctx.tools.length > 0) {
-    body.tools = [
-      {
-        function_declarations: ctx.tools.map((tool) => ({
-          name: tool.function.name,
-          description: tool.function.description,
-          parameters: tool.function.parameters
-        }))
-      }
-    ];
-  }
-  const endpoint = ctx.stream ? "streamGenerateContent" : "generateContent";
-  const response = await fetch(
-    `https://generativelanguage.googleapis.com/v1beta/models/${model2}:${endpoint}?key=${apiKey}${ctx.stream ? "&alt=sse" : ""}`,
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body),
-      signal: ctx.abortSignal
-    }
-  );
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Google API error: ${error}`);
-  }
-  if (ctx.stream) {
-    return handleGoogleStream(response, ctx);
-  }
-  const data = await response.json();
-  const candidate = data.candidates[0];
-  const parts = candidate.content.parts || [];
-  const msg = {
-    role: "assistant",
-    content: ""
-  };
-  const toolCalls = [];
-  for (const part of parts) {
-    if (part.text) {
-      msg.content += part.text;
-    }
-    if (part.functionCall) {
-      const tc = {
-        id: Math.random().toString(36).substring(2, 9),
-        type: "function",
-        function: {
-          name: part.functionCall.name,
-          arguments: JSON.stringify(part.functionCall.args)
-        }
-      };
-      if (part.thoughtSignature) {
-        tc.thoughtSignature = part.thoughtSignature;
-      }
-      toolCalls.push(tc);
-    }
-  }
-  if (toolCalls.length > 0) {
-    msg.tool_calls = toolCalls;
-  }
-  const um = data.usageMetadata;
-  return {
-    ...ctx,
-    lastResponse: msg,
-    history: [...ctx.history, msg],
-    usage: addUsage(ctx.usage, um?.promptTokenCount || 0, um?.candidatesTokenCount || 0, um?.totalTokenCount || 0)
-  };
-};
-var handleGoogleStream = async (response, ctx) => {
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let fullContent = "";
-  const toolCalls = [];
-  let buffer = "";
-  let usageMetadata = null;
-  try {
-    while (true) {
-      if (ctx.abortSignal?.aborted) {
-        break;
-      }
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data = line.slice(6).trim();
-          if (!data) continue;
-          try {
-            const parsed = JSON.parse(data);
-            if (parsed.usageMetadata) {
-              usageMetadata = parsed.usageMetadata;
-            }
-            const candidate = parsed.candidates?.[0];
-            const parts = candidate?.content?.parts || [];
-            for (const part of parts) {
-              if (part?.text) {
-                fullContent += part.text;
-                if (ctx.stream) {
-                  ctx.stream({ type: "content", content: part.text });
-                }
-              }
-              if (part?.functionCall) {
-                const tc = {
-                  id: Math.random().toString(36).substring(2, 9),
-                  type: "function",
-                  function: {
-                    name: part.functionCall.name,
-                    arguments: JSON.stringify(part.functionCall.args)
-                  }
-                };
-                if (part.thoughtSignature) {
-                  tc.thoughtSignature = part.thoughtSignature;
-                }
-                toolCalls.push(tc);
-              }
-            }
-          } catch (e) {
-          }
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const msg = {
-    role: "assistant",
-    content: fullContent
-  };
-  if (toolCalls.length > 0) {
-    msg.tool_calls = toolCalls;
-  }
-  const um = usageMetadata;
-  const usage = addUsage(ctx.usage, um?.promptTokenCount || 0, um?.candidatesTokenCount || 0, um?.totalTokenCount || 0);
-  if (ctx.stream && um) {
-    ctx.stream({ type: "usage", usage });
-  }
-  return {
-    ...ctx,
-    lastResponse: msg,
-    history: [...ctx.history, msg],
-    usage
-  };
-};
-
-// src/providers/huggingface.ts
-var modelCache2 = /* @__PURE__ */ new Map();
-var formatMessages = (instructions, history) => {
-  const messages = [];
-  if (instructions) {
-    messages.push({ role: "system", content: instructions });
-  }
-  for (const msg of history) {
-    messages.push({ role: msg.role, content: msg.content });
-  }
-  return messages;
-};
-var callHuggingFace = async (config, ctx) => {
-  const { model: model2, instructions, schema } = config;
-  const { pipeline } = await import("@huggingface/transformers");
-  if (!modelCache2.has(model2)) {
-    const generator2 = await pipeline("text-generation", model2, {
-      dtype: "q4"
-    });
-    modelCache2.set(model2, generator2);
-  }
-  const generator = modelCache2.get(model2);
-  const messages = formatMessages(instructions, ctx.history);
-  if (schema) {
-    const schemaMsg = messages.find((m) => m.role === "system");
-    const schemaInstructions = [
-      "you must respond with valid JSON matching this schema:",
-      JSON.stringify(schema.schema, null, 2),
-      "respond ONLY with the JSON object, no other text."
-    ].join("\n");
-    if (schemaMsg) {
-      schemaMsg.content += "\n\n" + schemaInstructions;
-    } else {
-      messages.unshift({ role: "system", content: schemaInstructions });
-    }
-  }
-  const output = await generator(messages, {
-    max_new_tokens: 2048,
-    do_sample: false
-  });
-  const generatedMessages = output[0].generated_text;
-  const lastMessage = generatedMessages.at(-1);
-  const content = lastMessage?.content || "";
-  const msg = {
-    role: "assistant",
-    content
-  };
-  if (ctx.stream) {
-    ctx.stream({ type: "content", content });
-  }
-  return {
-    ...ctx,
-    lastResponse: msg,
-    history: [...ctx.history, msg],
-    usage: addUsage(ctx.usage, 0, 0, 0)
-  };
-};
-
-// src/providers/xai.ts
-var appendToolCalls2 = (toolCalls, tcchunklist) => {
-  for (const tcchunk of tcchunklist) {
-    while (toolCalls.length <= tcchunk.index) {
-      toolCalls.push({
-        id: "",
-        type: "function",
-        function: { name: "", arguments: "" }
-      });
-    }
-    const tc = toolCalls[tcchunk.index];
-    tc.id += tcchunk.id || "";
-    tc.function.name += tcchunk.function?.name || "";
-    tc.function.arguments += tcchunk.function?.arguments || "";
-  }
-  return toolCalls;
-};
-var getApiKey5 = (configApiKey) => {
-  if (configApiKey) return configApiKey;
-  try {
-    return getKey("xai");
-  } catch {
-    const key = process.env.XAI_API_KEY || "";
-    if (!key) throw new Error("xAI API key not found");
-    return key;
-  }
-};
-var callXAI = async (config, ctx) => {
-  const { model: model2, instructions, schema, apiKey: configApiKey } = config;
-  const apiKey = getApiKey5(configApiKey);
-  const messages = [];
-  if (instructions) {
-    messages.push({ role: "system", content: instructions });
-  }
-  messages.push(...ctx.history);
-  const body = {
-    model: model2,
-    messages,
-    stream: !!ctx.stream,
-    ...ctx.stream && { stream_options: { include_usage: true } }
-  };
-  if (schema) {
-    body.response_format = {
-      type: "json_schema",
-      json_schema: {
-        name: schema.name,
-        schema: { ...schema.schema, additionalProperties: false },
-        strict: true
-      }
-    };
-  }
-  if (ctx.tools && ctx.tools.length > 0) {
-    body.tools = ctx.tools;
-    body.tool_choice = "auto";
-  }
-  const response = await fetch("https://api.x.ai/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify(body),
-    signal: ctx.abortSignal
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`xAI API error: ${error}`);
-  }
-  if (ctx.stream) {
-    return handleXAIStream(response, ctx);
-  }
-  const data = await response.json();
-  const choice = data.choices[0];
-  const { message } = choice;
-  const msg = {
-    role: "assistant",
-    content: message.content || ""
-  };
-  if (message.tool_calls) {
-    msg.tool_calls = message.tool_calls;
-  }
-  return {
-    ...ctx,
-    lastResponse: msg,
-    history: [...ctx.history, msg],
-    usage: addUsage(ctx.usage, data.usage?.prompt_tokens || 0, data.usage?.completion_tokens || 0, data.usage?.total_tokens || 0)
-  };
-};
-var handleXAIStream = async (response, ctx) => {
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let fullContent = "";
-  let toolCalls = [];
-  let buffer = "";
-  let streamUsage = null;
-  try {
-    while (true) {
-      if (ctx.abortSignal?.aborted) {
-        break;
-      }
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data = line.slice(6).trim();
-          if (data === "[DONE]") continue;
-          if (!data) continue;
-          try {
-            const parsed = JSON.parse(data);
-            if (parsed.usage) {
-              streamUsage = parsed.usage;
-            }
-            const delta = parsed.choices?.[0]?.delta;
-            if (delta?.content) {
-              fullContent += delta.content;
-              if (ctx.stream) {
-                ctx.stream({ type: "content", content: delta.content });
-              }
-            }
-            if (delta?.tool_calls) {
-              toolCalls = appendToolCalls2(toolCalls, delta.tool_calls);
-            }
-          } catch (e) {
-          }
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const msg = {
-    role: "assistant",
-    content: fullContent
-  };
-  if (toolCalls.length > 0) {
-    msg.tool_calls = toolCalls;
-  }
-  const usage = addUsage(ctx.usage, streamUsage?.prompt_tokens || 0, streamUsage?.completion_tokens || 0, streamUsage?.total_tokens || 0);
-  if (ctx.stream && streamUsage) {
-    ctx.stream({ type: "usage", usage });
-  }
-  return {
-    ...ctx,
-    lastResponse: msg,
-    history: [...ctx.history, msg],
-    usage
-  };
-};
-
-// src/providers/local.ts
-var DEFAULT_BASE_URL = "http://localhost:11434/v1";
-var appendToolCalls3 = (toolCalls, tcchunklist) => {
-  for (const tcchunk of tcchunklist) {
-    while (toolCalls.length <= tcchunk.index) {
-      toolCalls.push({
-        id: "",
-        type: "function",
-        function: { name: "", arguments: "" }
-      });
-    }
-    const tc = toolCalls[tcchunk.index];
-    tc.id += tcchunk.id || "";
-    tc.function.name += tcchunk.function?.name || "";
-    tc.function.arguments += tcchunk.function?.arguments || "";
-  }
-  return toolCalls;
-};
-var callLocal = async (config, ctx) => {
-  const { model: model2, instructions, schema, apiKey, baseUrl } = config;
-  const endpoint = baseUrl || DEFAULT_BASE_URL;
-  const messages = [];
-  if (instructions) {
-    messages.push({ role: "system", content: instructions });
-  }
-  messages.push(...ctx.history);
-  const body = {
-    model: model2,
-    messages,
-    stream: !!ctx.stream,
-    ...ctx.stream && { stream_options: { include_usage: true } }
-  };
-  if (schema) {
-    body.response_format = {
-      type: "json_schema",
-      json_schema: {
-        name: schema.name,
-        schema: { ...schema.schema, additionalProperties: false },
-        strict: true
-      }
-    };
-  }
-  if (ctx.tools && ctx.tools.length > 0) {
-    body.tools = ctx.tools;
-    body.tool_choice = "auto";
-  }
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (apiKey) {
-    headers["Authorization"] = `Bearer ${apiKey}`;
-  }
-  const response = await fetch(`${endpoint}/chat/completions`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-    signal: ctx.abortSignal
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Local API error: ${error}`);
-  }
-  if (ctx.stream) {
-    return handleLocalStream(response, ctx);
-  }
-  const data = await response.json();
-  const choice = data.choices[0];
-  const { message } = choice;
-  const msg = {
-    role: "assistant",
-    content: message.content || ""
-  };
-  if (message.tool_calls) {
-    msg.tool_calls = message.tool_calls;
-  }
-  return {
-    ...ctx,
-    lastResponse: msg,
-    history: [...ctx.history, msg],
-    usage: addUsage(ctx.usage, data.usage?.prompt_tokens || 0, data.usage?.completion_tokens || 0, data.usage?.total_tokens || 0)
-  };
-};
-var handleLocalStream = async (response, ctx) => {
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let fullContent = "";
-  let toolCalls = [];
-  let buffer = "";
-  let streamUsage = null;
-  try {
-    while (true) {
-      if (ctx.abortSignal?.aborted) {
-        break;
-      }
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data = line.slice(6).trim();
-          if (data === "[DONE]") continue;
-          if (!data) continue;
-          try {
-            const parsed = JSON.parse(data);
-            if (parsed.usage) {
-              streamUsage = parsed.usage;
-            }
-            const delta = parsed.choices?.[0]?.delta;
-            if (delta?.content) {
-              fullContent += delta.content;
-              if (ctx.stream) {
-                ctx.stream({ type: "content", content: delta.content });
-              }
-            }
-            if (delta?.tool_calls) {
-              toolCalls = appendToolCalls3(toolCalls, delta.tool_calls);
-            }
-          } catch (e) {
-          }
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const msg = {
-    role: "assistant",
-    content: fullContent
-  };
-  if (toolCalls.length > 0) {
-    msg.tool_calls = toolCalls;
-  }
-  const usage = addUsage(ctx.usage, streamUsage?.prompt_tokens || 0, streamUsage?.completion_tokens || 0, streamUsage?.total_tokens || 0);
-  if (ctx.stream && streamUsage) {
-    ctx.stream({ type: "usage", usage });
-  }
-  return {
-    ...ctx,
-    lastResponse: msg,
-    history: [...ctx.history, msg],
-    usage
-  };
-};
-
-// src/providers/index.ts
-var callProvider = async (config, ctx) => {
-  const { provider, model: model2 } = parseModelName(config.model);
-  const providerConfig = { ...config, model: model2 };
-  switch (provider.toLowerCase()) {
-    case "openai":
-      return callOpenAI(providerConfig, ctx);
-    case "anthropic":
-      return callAnthropic(providerConfig, ctx);
-    case "google":
-      return callGoogle(providerConfig, ctx);
-    case "xai":
-      return callXAI(providerConfig, ctx);
-    case "local":
-      return callLocal(providerConfig, ctx);
-    case "huggingface":
-      return callHuggingFace(providerConfig, ctx);
-    default:
-      return callHuggingFace({ ...config }, ctx);
-  }
-};
-
-// src/approval.ts
-import { EventEmitter } from "events";
-var state = {
-  resolvers: /* @__PURE__ */ new Map(),
-  emitter: new EventEmitter()
-};
-var generateApprovalToken = () => {
-  return `approval_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-};
-var requestApproval = async (toolCall, approvalId) => {
-  const id = generateApprovalToken();
-  const request = { id, toolCall, approvalId };
-  state.emitter.emit("approvalRequested", request);
-  return new Promise((resolve) => {
-    state.resolvers.set(id, resolve);
-  });
-};
-var resolveApproval = (response) => {
-  const resolver = state.resolvers.get(response.id);
-  if (!resolver) return false;
-  state.resolvers.delete(response.id);
-  resolver(response);
-  state.emitter.emit("approvalResolved", response);
-  return true;
-};
-var onApprovalRequested = (listener) => {
-  state.emitter.on("approvalRequested", listener);
-};
-var onApprovalResolved = (listener) => {
-  state.emitter.on("approvalResolved", listener);
-};
-var removeApprovalListener = (event, listener) => {
-  state.emitter.removeListener(event, listener);
-};
-
-// src/composition/model.ts
-var model = ({
-  model: model2 = "openai/gpt-4o-mini",
-  schema,
-  system,
-  apiKey,
-  baseUrl
-} = {}) => {
-  return async (ctxOrMessage) => {
-    const ctx = typeof ctxOrMessage === "string" ? (
-      // model()("hello!");
-      {
-        history: [{ role: "user", content: ctxOrMessage }],
-        tools: []
-      }
-    ) : (
-      // model()(/* few shot or history */);
-      ctxOrMessage
-    );
-    const normalizedSchema = schema ? normalizeSchema(schema) : void 0;
-    let currentCtx = ctx;
-    if (system) {
-      const systemContent = typeof system === "function" ? system(currentCtx) : system;
-      const [first, ...rest] = currentCtx.history;
-      if (first?.role === "system") {
-        currentCtx = {
-          ...currentCtx,
-          history: [{ role: "system", content: systemContent }, ...rest]
-        };
-      } else {
-        currentCtx = {
-          ...currentCtx,
-          history: [{ role: "system", content: systemContent }, ...currentCtx.history]
-        };
-      }
-    }
-    const systemMessage = currentCtx.history.find((m) => m.role === "system");
-    const instructions = systemMessage?.content;
-    do {
-      if (currentCtx.abortSignal?.aborted) {
-        break;
-      }
-      currentCtx = await callProvider(
-        { model: model2, instructions, schema: normalizedSchema, apiKey, baseUrl },
-        currentCtx
-      );
-      if (currentCtx.lastResponse?.tool_calls && currentCtx.tools?.length) {
-        currentCtx = await executeTools(currentCtx);
-      }
-    } while (currentCtx.lastResponse?.tool_calls && currentCtx.tools?.length && !currentCtx.abortSignal?.aborted);
-    return currentCtx;
-  };
-};
-var executeTools = async (ctx) => {
-  const calls = ctx.lastResponse?.tool_calls || [];
-  if (!calls.length) return ctx;
-  if (ctx.stream) {
-    ctx.stream({ type: "tool_calls_ready", calls });
-  }
-  const toolConfig = ctx.toolConfig || {};
-  const {
-    requireApproval = false,
-    approvalCallback,
-    parallel = false,
-    retryCount = 0,
-    approvalId,
-    executeOnApproval = false
-  } = toolConfig;
-  const updatedCounts = { ...ctx.toolCallCounts || {} };
-  const runCall = async (call, approved) => {
-    if (!approved) {
-      if (ctx.stream) {
-        ctx.stream({
-          type: "tool_error",
-          call,
-          error: "Tool execution denied by user"
-        });
-      }
-      return {
-        call,
-        result: { error: "Tool execution denied by user" }
-      };
-    }
-    const toolName = call.function.name;
-    const limits = ctx.toolLimits || {};
-    const maxCalls2 = limits[toolName];
-    const currentCount = updatedCounts[toolName] || 0;
-    if (maxCalls2 && currentCount >= maxCalls2) {
-      const error2 = `Tool ${toolName} has reached its limit of ${maxCalls2} calls`;
-      if (ctx.stream) {
-        ctx.stream({ type: "tool_error", call, error: error2 });
-      }
-      return {
-        call,
-        result: { error: error2 }
-      };
-    }
-    updatedCounts[toolName] = currentCount + 1;
-    if (ctx.stream) {
-      ctx.stream({ type: "tool_executing", call });
-    }
-    let lastError;
-    for (let i = 0; i <= retryCount; i++) {
-      try {
-        const executor = ctx.toolExecutors?.[call.function.name];
-        if (!executor) {
-          throw new Error(`Tool executor not found: ${call.function.name}`);
-        }
-        let args = {};
-        try {
-          args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
-        } catch (e) {
-          throw new Error(
-            `Invalid JSON arguments for tool ${call.function.name}: ${call.function.arguments}`
-          );
-        }
-        const result = await executor(args);
-        if (ctx.stream) {
-          ctx.stream({ type: "tool_complete", call, result });
-        }
-        return { call, result };
-      } catch (e) {
-        lastError = e;
-      }
-    }
-    const error = lastError.message;
-    if (ctx.stream) {
-      ctx.stream({ type: "tool_error", call, error });
-    }
-    return { call, result: { error } };
-  };
-  if (executeOnApproval && requireApproval) {
-    const resultPromises = calls.map(async (call) => {
-      let approved;
-      if (approvalCallback) {
-        approved = await approvalCallback(call);
-      } else {
-        const response = await requestApproval(call, approvalId);
-        approved = response.approved;
-      }
-      return runCall(call, approved);
-    });
-    const results2 = await Promise.all(resultPromises);
-    return {
-      ...ctx,
-      history: [
-        ...ctx.history,
-        ...results2.map(({ call, result }) => ({
-          role: "tool",
-          tool_call_id: call.id,
-          content: JSON.stringify(result)
-        }))
-      ],
-      toolCallCounts: updatedCounts
-    };
-  }
-  const approvalPromises = calls.map(async (call) => {
-    if (requireApproval) {
-      let approved;
-      if (approvalCallback) {
-        approved = await approvalCallback(call);
-      } else {
-        const response = await requestApproval(call, approvalId);
-        approved = response.approved;
-      }
-      return { call, approved };
-    } else {
-      return { call, approved: true };
-    }
-  });
-  const approvals = await Promise.all(approvalPromises);
-  const runCallWithApproval = async (call) => {
-    const approval = approvals.find((a) => a.call.id === call.id);
-    return runCall(call, approval?.approved ?? true);
-  };
-  const results = parallel ? await Promise.all(calls.map(runCallWithApproval)) : await runCallsSequentially(calls, runCallWithApproval);
-  return {
-    ...ctx,
-    history: [
-      ...ctx.history,
-      ...results.map(({ call, result }) => ({
-        role: "tool",
-        tool_call_id: call.id,
-        content: JSON.stringify(result)
-      }))
-    ],
-    toolCallCounts: updatedCounts
-  };
-};
-var runCallsSequentially = async (calls, runCall) => {
-  const results = [];
-  for (const call of calls) {
-    results.push(await runCall(call));
-  }
-  return results;
-};
-
-// src/thread.ts
-var createMemoryStore = () => {
-  const store = /* @__PURE__ */ new Map();
-  return {
-    async get(threadId) {
-      return store.get(threadId) || [];
-    },
-    async set(threadId, messages) {
-      store.set(threadId, messages);
-    }
-  };
-};
-var createThread = (id, store) => {
-  return {
-    id,
-    store,
-    async generate(workflow) {
-      const history = await store.get(id);
-      const initialContext = {
-        history,
-        tools: [],
-        toolExecutors: {},
-        toolLimits: {},
-        toolCallCounts: {}
-      };
-      const finalContext = await workflow(initialContext);
-      await store.set(id, finalContext.history);
-      return finalContext;
-    },
-    async message(content, workflow, options) {
-      const history = await store.get(id);
-      const initialContext = {
-        history: [...history, { role: "user", content }],
-        tools: [],
-        toolExecutors: {},
-        toolLimits: {},
-        toolCallCounts: {},
-        abortSignal: options?.abortSignal
-      };
-      const finalContext = await (workflow || model())(initialContext);
-      if (options?.abortSignal?.aborted) {
-        const abortedHistory = [
-          ...initialContext.history,
-          { role: "assistant", content: "[Response interrupted]" }
-        ];
-        await store.set(id, abortedHistory);
-        return { ...finalContext, history: abortedHistory };
-      }
-      await store.set(id, finalContext.history);
-      return finalContext;
-    }
-  };
-};
-var threads = /* @__PURE__ */ new Map();
-var getOrCreateThread = (id, store) => {
-  const cacheKey = store ? `${id}-${store}` : id;
-  if (threads.has(cacheKey)) {
-    return threads.get(cacheKey);
-  }
-  const threadStore = store || createMemoryStore();
-  const thread = createThread(id, threadStore);
-  threads.set(cacheKey, thread);
-  return thread;
-};
-
-// src/composition/when.ts
-var when = (condition, action) => {
-  return async (ctx) => {
-    if (condition(ctx)) {
-      return await action(ctx);
-    }
-    return ctx;
-  };
-};
-
-// src/helpers.ts
-var noToolsCalled = () => (ctx) => {
-  return !ctx.lastResponse?.tool_calls || ctx.lastResponse.tool_calls.length === 0;
-};
-var everyNMessages = (n, step) => {
-  let lastTriggeredAt = 0;
-  return when(
-    (ctx) => Math.floor(ctx.history.length / n) > Math.floor(lastTriggeredAt / n),
-    async (ctx) => {
-      lastTriggeredAt = ctx.history.length;
-      return await step(ctx);
-    }
-  );
-};
-var everyNTokens = (n, step) => {
-  let lastTriggeredAt = 0;
-  return when(
-    (ctx) => {
-      const totalTokens = ctx.history.reduce(
-        (acc, msg) => acc + Math.ceil(msg.content.length / 4),
-        0
-      );
-      return Math.floor(totalTokens / n) > Math.floor(lastTriggeredAt / n);
-    },
-    async (ctx) => {
-      const totalTokens = ctx.history.reduce(
-        (acc, msg) => acc + Math.ceil(msg.content.length / 4),
-        0
-      );
-      lastTriggeredAt = totalTokens;
-      return await step(ctx);
-    }
-  );
-};
-var appendToLastRequest = (content) => {
-  return async (ctx) => {
-    let lastUserIndex = -1;
-    for (let i = ctx.history.length - 1; i >= 0; i--) {
-      if (ctx.history[i].role === "user") {
-        lastUserIndex = i;
-        break;
-      }
-    }
-    if (lastUserIndex === -1) return ctx;
-    const newHistory = [...ctx.history];
-    newHistory[lastUserIndex] = {
-      ...newHistory[lastUserIndex],
-      content: newHistory[lastUserIndex].content + content
-    };
-    return {
-      ...ctx,
-      history: newHistory
-    };
-  };
-};
-var toolNotUsedInNTurns = ({ toolName, times }, step) => {
-  let turnsSinceLastUsed = 0;
-  let lastProcessedTurn = -1;
-  return when((ctx) => {
-    const currentTurn = getCurrentTurn(ctx);
-    if (currentTurn === lastProcessedTurn) return false;
-    lastProcessedTurn = currentTurn;
-    const toolUsedInTurn = wasToolUsedInCurrentTurn(ctx, toolName);
-    if (toolUsedInTurn) {
-      turnsSinceLastUsed = 0;
-      return false;
-    } else {
-      turnsSinceLastUsed++;
-      return turnsSinceLastUsed >= times;
-    }
-  }, step);
-};
-var getCurrentTurn = (ctx) => {
-  let turns = 0;
-  for (const msg of ctx.history) {
-    if (msg.role === "user") turns++;
-  }
-  return turns;
-};
-var wasToolUsedInCurrentTurn = (ctx, toolName) => {
-  let lastUserIndex = -1;
-  for (let i = ctx.history.length - 1; i >= 0; i--) {
-    if (ctx.history[i].role === "user") {
-      lastUserIndex = i;
-      break;
-    }
-  }
-  if (lastUserIndex === -1) return false;
-  for (let i = lastUserIndex + 1; i < ctx.history.length; i++) {
-    const msg = ctx.history[i];
-    if (msg.role === "assistant" && ctx.lastResponse?.tool_calls) {
-      return ctx.lastResponse.tool_calls.some(
-        (call) => call.function.name === toolName
-      );
-    }
-  }
-  return false;
-};
-var toolWasCalled = (name) => (ctx) => {
-  return !!ctx.lastResponse?.tool_calls && ctx.lastResponse.tool_calls.some((call) => call.function.name === name);
-};
-
-// src/composition/tap.ts
-var tap = (fn) => {
-  return async (ctx) => {
-    await fn(ctx);
-    return ctx;
-  };
-};
-
-// src/composition/retry.ts
-var retry = ({ times = 3 } = {}, step) => {
-  return async (ctx) => {
-    let err;
-    for (let i = 0; i < times; i++) {
-      try {
-        return await step(ctx);
-      } catch (e) {
-        err = e;
-      }
-    }
-    throw err;
-  };
-};
-
-// src/composition/compose.ts
-var enrichContext = (ctx) => {
-  const lastUserMessage = [...ctx.history].reverse().find((msg) => msg.role === "user");
-  return {
-    ...ctx,
-    lastRequest: lastUserMessage
-  };
-};
-var compose = (...steps) => {
-  return async (ctxOrMessage) => {
-    let initialContext;
-    if (typeof ctxOrMessage === "string") {
-      initialContext = {
-        history: [{ role: "user", content: ctxOrMessage }],
-        tools: [],
-        toolExecutors: {},
-        toolLimits: {},
-        toolCallCounts: {}
-      };
-    } else {
-      initialContext = ctxOrMessage || {
-        history: [],
-        tools: [],
-        toolExecutors: {},
-        toolLimits: {},
-        toolCallCounts: {}
-      };
-    }
-    let next = enrichContext(initialContext);
-    for (const step of steps) {
-      next = await step(enrichContext(next));
-    }
-    return next;
-  };
-};
-
-// src/composition/scope.ts
-var scopeContext = (config, ctx) => {
-  const inherit = config.inherit ?? 1 /* Conversation */;
-  let scopedCtx = {
-    history: [],
-    tools: [],
-    toolExecutors: {},
-    toolLimits: {},
-    toolCallCounts: {}
-  };
-  if (inherit & 1 /* Conversation */) {
-    scopedCtx.history = ctx.history;
-    scopedCtx.lastResponse = ctx.lastResponse;
-    scopedCtx.lastRequest = ctx.lastRequest;
-  }
-  if (inherit & 2 /* Tools */) {
-    scopedCtx.tools = [...ctx.tools || []];
-    scopedCtx.toolExecutors = { ...ctx.toolExecutors || {} };
-    scopedCtx.toolLimits = { ...ctx.toolLimits || {} };
-    scopedCtx.toolCallCounts = { ...ctx.toolCallCounts || {} };
-    scopedCtx.toolConfig = ctx.toolConfig ? { ...ctx.toolConfig } : void 0;
-  }
-  scopedCtx.stream = ctx.stream;
-  scopedCtx.abortSignal = ctx.abortSignal;
-  scopedCtx.usage = ctx.usage;
-  if (config.tools) {
-    const toolDefinitions = config.tools.map(toolConfigToToolDefinition);
-    const toolExecutors = config.tools.reduce(
-      (acc, tool) => {
-        acc[tool.name] = tool.execute;
-        return acc;
-      },
-      {}
-    );
-    const toolLimits = config.tools.reduce(
-      (acc, tool) => {
-        if (tool._maxCalls) {
-          acc[tool.name] = tool._maxCalls;
-        }
-        return acc;
-      },
-      {}
-    );
-    scopedCtx.tools = toolDefinitions;
-    scopedCtx.toolExecutors = toolExecutors;
-    scopedCtx.toolLimits = toolLimits;
-  }
-  if (config.toolConfig) {
-    scopedCtx.toolConfig = { ...config.toolConfig };
-  }
-  if (config.system) {
-    const [first, ...rest] = scopedCtx.history;
-    if (first?.role === "system") {
-      scopedCtx.history = [{ role: "system", content: config.system }, ...rest];
-    } else {
-      scopedCtx.history = [{ role: "system", content: config.system }, ...scopedCtx.history];
-    }
-  }
-  if (config.stream) {
-    scopedCtx.stream = config.stream;
-  }
-  return scopedCtx;
-};
-var scope = (config, ...steps) => {
-  return async (ctx) => {
-    let scopedCtx = scopeContext(config, ctx);
-    if (config.until) {
-      do {
-        scopedCtx = await compose(...steps)(scopedCtx);
-      } while (!config.until(scopedCtx));
-    } else {
-      scopedCtx = await compose(...steps)(scopedCtx);
-    }
-    return {
-      ...ctx,
-      history: config.silent ? ctx.history : scopedCtx.history,
-      lastResponse: config.silent ? ctx.lastResponse : scopedCtx.lastResponse,
-      lastRequest: config.silent ? ctx.lastRequest : scopedCtx.lastRequest,
-      stopReason: config.silent ? ctx.stopReason : scopedCtx.stopReason,
-      usage: scopedCtx.usage
-    };
-  };
-};
-
-// src/utils/rateLimited.ts
-var rateLimited = (config) => (fn) => {
-  const { rps, burst, concurrency } = config;
-  let tokens = burst;
-  let inFlight = 0;
-  const queue = [];
-  let intervalId = null;
-  const refillTokens = () => {
-    tokens = Math.min(tokens + 1, burst);
-    processQueue();
-  };
-  const startInterval = () => {
-    if (!intervalId) {
-      intervalId = setInterval(refillTokens, 1e3 / rps);
-    }
-  };
-  const stopInterval = () => {
-    if (intervalId && queue.length === 0 && inFlight === 0) {
-      clearInterval(intervalId);
-      intervalId = null;
-    }
-  };
-  const processQueue = () => {
-    while (queue.length > 0 && tokens > 0 && inFlight < concurrency) {
-      tokens--;
-      inFlight++;
-      const item = queue.shift();
-      item.fn().then((result) => {
-        inFlight--;
-        item.resolve(result);
-        processQueue();
-        stopInterval();
-      }).catch((error) => {
-        inFlight--;
-        item.reject(error);
-        processQueue();
-        stopInterval();
-      });
-    }
-  };
-  return (async (...args) => {
-    return new Promise((resolve, reject) => {
-      queue.push({
-        fn: () => fn(...args),
-        resolve,
-        reject
-      });
-      startInterval();
-      processQueue();
-    });
-  });
-};
-export {
-  IMAGE_EDIT_MODEL_SCHEMA,
-  IMAGE_MODEL_SCHEMA,
-  Inherit,
-  addUsage,
-  appendToLastRequest,
-  compose,
-  convertMCPSchemaToToolSchema,
-  convertStandardSchemaToJsonSchema,
-  convertStandardSchemaToSchemaProperties,
-  createMCPTools,
-  embed,
-  everyNMessages,
-  everyNTokens,
-  generateApprovalToken,
-  generateImage,
-  getDefaultConfig,
-  getKey,
-  getModelConfig,
-  getOrCreateThread,
-  isStandardSchema,
-  maxCalls,
-  model,
-  noToolsCalled,
-  normalizeSchema,
-  onApprovalRequested,
-  onApprovalResolved,
-  parseModelName,
-  rateLimited,
-  removeApprovalListener,
-  requestApproval,
-  resolveApproval,
-  retry,
-  scope,
-  setKeys,
-  tap,
-  toolConfigToToolDefinition,
-  toolNotUsedInNTurns,
-  toolWasCalled,
-  when
-};
+export * from "./mcp";
+export * from "./types";
+export * from "./utils";
+export * from "./embed";
+export * from "./image";
+export * from "./image-model-schema";
+export * from "./thread";
+export * from "./schema";
+export * from "./helpers";
+export * from "./approval";
+export * from "./composition/tap";
+export * from "./composition/when";
+export * from "./composition/model";
+export * from "./composition/retry";
+export * from "./composition/scope";
+export * from "./utils/rateLimited";
+export * from "./composition/compose";
 //# sourceMappingURL=index.js.map