@threaded/ai 1.0.19 → 1.0.21

package/dist/index.cjs

@@ -905,6 +905,9 @@ var callGoogle = async (config, ctx) => {
           } catch {
             responseData = { result: toolMsg.content };
           }
+          if (Array.isArray(responseData)) {
+            responseData = { result: responseData };
+          }
           responseParts.push({
             functionResponse: {
               name: functionName,
@@ -1210,6 +1213,141 @@ var handleXAIStream = async (response, ctx) => {
   };
 };
 
+// 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
+  };
+  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]
+  };
+};
+var handleLocalStream = 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 = appendToolCalls3(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);
@@ -1223,6 +1361,8 @@ var callProvider = async (config, ctx) => {
       return callGoogle(providerConfig, ctx);
     case "xai":
       return callXAI(providerConfig, ctx);
+    case "local":
+      return callLocal(providerConfig, ctx);
     case "huggingface":
     default:
       return callHuggingFace(providerConfig, ctx);