@threaded/ai 1.0.1 → 1.0.3

package/dist/index.js

@@ -1,29 +1,14 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
 // src/schema.ts
+import { z } from "zod";
 var isStandardSchema = (schema) => {
   return schema && typeof schema === "object" && "~standard" in schema;
 };
 var convertStandardSchemaToJsonSchema = (standardSchema, name = "Schema") => {
-  try {
-    const zodModule = __require("zod");
-    if (zodModule && typeof zodModule.toJSONSchema === "function") {
-      const jsonSchema = zodModule.toJSONSchema(standardSchema);
-      return {
-        name,
-        schema: jsonSchema
-      };
-    }
-  } catch (error) {
-  }
-  throw new Error(
-    "Standard Schema conversion requires zod v4+ with toJSONSchema support. Please install zod@^4.0.0 or provide a JsonSchema object instead."
-  );
+  const jsonSchema = z.toJSONSchema(standardSchema);
+  return {
+    name,
+    schema: jsonSchema
+  };
 };
 var convertMCPSchemaToToolSchema = (mcpSchema) => {
   if (!mcpSchema?.properties) return {};
@@ -44,6 +29,10 @@ function normalizeSchema(schema, name) {
   }
   return schema;
 }
+var convertStandardSchemaToSchemaProperties = (standardSchema) => {
+  const jsonSchema = z.toJSONSchema(standardSchema);
+  return convertMCPSchemaToToolSchema(jsonSchema);
+};
 
 // src/mcp.ts
 var createMCPTools = async (client) => {
@@ -82,9 +71,10 @@ var Inherit = /* @__PURE__ */ ((Inherit2) => {
 
 // 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(tool.schema)) {
+  for (const [key, prop] of Object.entries(schema)) {
     properties[key] = convertSchemaProperty(prop);
     if (!prop.optional) {
       required.push(key);
@@ -150,7 +140,66 @@ var maxCalls = (toolConfig, maxCalls2) => ({
   _maxCalls: maxCalls2
 });
 
+// src/embed.ts
+import { pipeline } from "@huggingface/transformers";
+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;
+  }
+  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);
+};
+
 // src/providers/openai.ts
+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 } = config;
   const apiKey = getKey("openai") || process.env.OPENAI_API_KEY;
@@ -217,17 +266,19 @@ var handleOpenAIStream = async (response, ctx) => {
   const decoder = new TextDecoder();
   let fullContent = "";
   let toolCalls = [];
-  const toolCallsBuffer = {};
+  let buffer = "";
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
-      const chunk = decoder.decode(value);
-      const lines = chunk.split("\n");
+      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);
+          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;
@@ -238,25 +289,7 @@ var handleOpenAIStream = async (response, ctx) => {
               }
             }
             if (delta?.tool_calls) {
-              for (const toolCall of delta.tool_calls) {
-                const { index } = toolCall;
-                if (!toolCallsBuffer[index]) {
-                  toolCallsBuffer[index] = {
-                    id: toolCall.id || "",
-                    type: "function",
-                    function: { name: "", arguments: "" }
-                  };
-                }
-                if (toolCall.id) {
-                  toolCallsBuffer[index].id = toolCall.id;
-                }
-                if (toolCall.function?.name) {
-                  toolCallsBuffer[index].function.name += toolCall.function.name;
-                }
-                if (toolCall.function?.arguments) {
-                  toolCallsBuffer[index].function.arguments += toolCall.function.arguments;
-                }
-              }
+              toolCalls = appendToolCalls(toolCalls, delta.tool_calls);
             }
           } catch (e) {
           }
@@ -266,7 +299,6 @@ var handleOpenAIStream = async (response, ctx) => {
   } finally {
     reader.releaseLock();
   }
-  toolCalls = Object.values(toolCallsBuffer);
   const msg = {
     role: "assistant",
     content: fullContent
@@ -282,18 +314,66 @@ var handleOpenAIStream = async (response, ctx) => {
 };
 
 // src/providers/anthropic.ts
+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 } = config;
   const apiKey = getKey("anthropic") || process.env.ANTHROPIC_API_KEY;
   if (!apiKey) {
     throw new Error("Anthropic API key not found");
   }
-  const messages = [...ctx.history];
   let system = instructions;
-  if (messages[0]?.role === "system") {
-    system = messages[0].content;
-    messages.shift();
+  if (ctx.history[0]?.role === "system") {
+    system = ctx.history[0].content;
   }
+  const messages = convertToAnthropicFormat(ctx.history);
   if (schema) {
     const schemaPrompt = `
 
@@ -368,15 +448,18 @@ var handleAnthropicStream = async (response, ctx) => {
   const decoder = new TextDecoder();
   let fullContent = "";
   const toolCalls = [];
+  let buffer = "";
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
-      const chunk = decoder.decode(value);
-      const lines = chunk.split("\n");
+      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);
+          const data = line.slice(6).trim();
+          if (!data) continue;
           try {
             const parsed = JSON.parse(data);
             if (parsed.type === "content_block_delta" && parsed.delta?.text) {
@@ -392,10 +475,17 @@ var handleAnthropicStream = async (response, ctx) => {
                 type: "function",
                 function: {
                   name: toolUse.name,
-                  arguments: JSON.stringify(toolUse.input)
-                }
+                  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) {
           }
         }
@@ -409,7 +499,7 @@ var handleAnthropicStream = async (response, ctx) => {
     content: fullContent
   };
   if (toolCalls.length > 0) {
-    msg.tool_calls = toolCalls;
+    msg.tool_calls = toolCalls.map(({ index, ...tc }) => tc);
   }
   return {
     ...ctx,
@@ -505,15 +595,18 @@ var handleGoogleStream = async (response, ctx) => {
   const decoder = new TextDecoder();
   let fullContent = "";
   const toolCalls = [];
+  let buffer = "";
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
-      const chunk = decoder.decode(value);
-      const lines = chunk.split("\n");
+      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);
+          const data = line.slice(6).trim();
+          if (!data) continue;
           try {
             const parsed = JSON.parse(data);
             const candidate = parsed.candidates?.[0];
@@ -621,10 +714,16 @@ var model = ({
   schema
 } = {}) => {
   return async (ctxOrMessage) => {
-    const ctx = typeof ctxOrMessage === "string" ? {
-      history: [{ role: "user", content: ctxOrMessage }],
-      tools: []
-    } : 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;
     const systemMessage = ctx.history.find((m) => m.role === "system");
     const instructions = systemMessage?.content;
@@ -653,29 +752,18 @@ var executeTools = async (ctx) => {
     approvalCallback,
     parallel = false,
     retryCount = 0,
-    approvalId
+    approvalId,
+    executeOnApproval = false
   } = toolConfig;
-  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 updatedCounts = { ...ctx.toolCallCounts || {} };
-  const runCall = async (call) => {
-    const approval = approvals.find((a) => a.call.id === call.id);
-    if (!approval?.approved) {
+  const runCall = async (call, approved) => {
+    if (!approved) {
       if (ctx.stream) {
-        ctx.stream({ type: "tool_error", call, error: "Tool execution denied by user" });
+        ctx.stream({
+          type: "tool_error",
+          call,
+          error: "Tool execution denied by user"
+        });
       }
       return {
         call,
@@ -730,7 +818,51 @@ var executeTools = async (ctx) => {
     }
     return { call, result: { error } };
   };
-  const results = parallel ? await Promise.all(calls.map(runCall)) : await runCallsSequentially(calls, runCall);
+  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: [
@@ -796,14 +928,15 @@ var createThread = (id, store) => {
     }
   };
 };
-var defaultStore = createMemoryStore();
 var threads = /* @__PURE__ */ new Map();
-var getOrCreateThread = (id, store = defaultStore) => {
-  if (threads.has(id)) {
-    return threads.get(id);
+var getOrCreateThread = (id, store) => {
+  const cacheKey = store ? `${id}-${store}` : id;
+  if (threads.has(cacheKey)) {
+    return threads.get(cacheKey);
   }
-  const thread = createThread(id, store);
-  threads.set(id, thread);
+  const threadStore = store || createMemoryStore();
+  const thread = createThread(id, threadStore);
+  threads.set(cacheKey, thread);
   return thread;
 };
 
@@ -1034,6 +1167,9 @@ var scopeContext = (config, ctx) => {
       scopedCtx.history = [{ role: "system", content: config.system }, ...scopedCtx.history];
     }
   }
+  if (config.stream) {
+    scopedCtx.stream = config.stream;
+  }
   return scopedCtx;
 };
 var scope = (config, ...steps) => {
@@ -1055,13 +1191,68 @@ var scope = (config, ...steps) => {
     };
   };
 };
+
+// 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 {
   Inherit,
   appendToLastRequest,
   compose,
   convertMCPSchemaToToolSchema,
   convertStandardSchemaToJsonSchema,
+  convertStandardSchemaToSchemaProperties,
   createMCPTools,
+  embed,
   everyNMessages,
   everyNTokens,
   generateApprovalToken,
@@ -1075,6 +1266,7 @@ export {
   onApprovalRequested,
   onApprovalResolved,
   parseModelName,
+  rateLimited,
   removeApprovalListener,
   requestApproval,
   resolveApproval,