@threaded/ai 1.0.2 → 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,6 +140,49 @@ 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) {
@@ -281,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 = `
 
@@ -394,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) {
           }
         }
@@ -411,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,
@@ -633,7 +721,7 @@ var model = ({
         tools: []
       }
     ) : (
-      // model()(/* few shot / history */);
+      // model()(/* few shot or history */);
       ctxOrMessage
     );
     const normalizedSchema = schema ? normalizeSchema(schema) : void 0;
@@ -664,27 +752,12 @@ 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",
@@ -745,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: [
@@ -1074,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,
@@ -1094,6 +1266,7 @@ export {
   onApprovalRequested,
   onApprovalResolved,
   parseModelName,
+  rateLimited,
   removeApprovalListener,
   requestApproval,
   resolveApproval,