@threaded/ai 1.0.8 → 1.0.10

package/dist/index.js

@@ -12,14 +12,23 @@ var convertStandardSchemaToJsonSchema = (standardSchema, name = "Schema") => {
 };
 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] = {
-      type: prop.type || "string",
-      description: prop.description || "",
-      optional: !mcpSchema.required?.includes(key),
-      ...prop.enum && { enum: prop.enum }
+      ...convertProperty(prop),
+      optional: !mcpSchema.required?.includes(key)
     };
   }
   return result;
@@ -307,6 +316,16 @@ var generateImage = async (model2, prompt, config) => {
 };
 
 // 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) {
@@ -325,10 +344,7 @@ var appendToolCalls = (toolCalls, tcchunklist) => {
 };
 var callOpenAI = async (config, ctx) => {
   const { model: model2, instructions, schema, apiKey: configApiKey } = config;
-  const apiKey = configApiKey || getKey("openai") || process.env.OPENAI_API_KEY;
-  if (!apiKey) {
-    throw new Error("OpenAI API key not found");
-  }
+  const apiKey = getApiKey2(configApiKey);
   const messages = [];
   if (instructions) {
     messages.push({ role: "system", content: instructions });
@@ -441,6 +457,16 @@ var handleOpenAIStream = async (response, ctx) => {
 };
 
 // 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;
@@ -492,10 +518,7 @@ var convertToAnthropicFormat = (messages) => {
 };
 var callAnthropic = async (config, ctx) => {
   const { model: model2, instructions, schema, apiKey: configApiKey } = config;
-  const apiKey = configApiKey || getKey("anthropic") || process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) {
-    throw new Error("Anthropic API key not found");
-  }
+  const apiKey = getApiKey3(configApiKey);
   let system = instructions;
   if (ctx.history[0]?.role === "system") {
     system = ctx.history[0].content;
@@ -640,12 +663,19 @@ var handleAnthropicStream = async (response, ctx) => {
 };
 
 // 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 = configApiKey || getKey("google") || process.env.GOOGLE_AI_API_KEY;
-  if (!apiKey) {
-    throw new Error("Google API key not found");
-  }
+  const apiKey = getApiKey4(configApiKey);
   const contents = [];
   if (instructions) {
     contents.push({
@@ -680,7 +710,7 @@ var callGoogle = async (config, ctx) => {
   }
   const endpoint = ctx.stream ? "streamGenerateContent" : "generateContent";
   const response = await fetch(
-    `https://generativelanguage.googleapis.com/v1beta/models/${model2}:${endpoint}?key=${apiKey}`,
+    `https://generativelanguage.googleapis.com/v1beta/models/${model2}:${endpoint}?key=${apiKey}${ctx.stream ? "&alt=sse" : ""}`,
     {
       method: "POST",
       headers: {
@@ -791,6 +821,147 @@ var callHuggingFace = async (config, ctx) => {
   );
 };
 
+// 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
+  };
+  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]
+  };
+};
+var handleXAIStream = async (response, ctx) => {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let fullContent = "";
+  let toolCalls = [];
+  let buffer = "";
+  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);
+            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;
+  }
+  return {
+    ...ctx,
+    lastResponse: msg,
+    history: [...ctx.history, msg]
+  };
+};
+
 // src/providers/index.ts
 var callProvider = async (config, ctx) => {
   const { provider, model: model2 } = parseModelName(config.model);
@@ -802,6 +973,8 @@ var callProvider = async (config, ctx) => {
       return callAnthropic(providerConfig, ctx);
     case "google":
       return callGoogle(providerConfig, ctx);
+    case "xai":
+      return callXAI(providerConfig, ctx);
     case "huggingface":
     default:
       return callHuggingFace(providerConfig, ctx);