@threaded/ai 1.0.2 → 1.0.3

package/dist/index.cjs

@@ -25,7 +25,9 @@ __export(index_exports, {
   compose: () => compose,
   convertMCPSchemaToToolSchema: () => convertMCPSchemaToToolSchema,
   convertStandardSchemaToJsonSchema: () => convertStandardSchemaToJsonSchema,
+  convertStandardSchemaToSchemaProperties: () => convertStandardSchemaToSchemaProperties,
   createMCPTools: () => createMCPTools,
+  embed: () => embed,
   everyNMessages: () => everyNMessages,
   everyNTokens: () => everyNTokens,
   generateApprovalToken: () => generateApprovalToken,
@@ -39,6 +41,7 @@ __export(index_exports, {
   onApprovalRequested: () => onApprovalRequested,
   onApprovalResolved: () => onApprovalResolved,
   parseModelName: () => parseModelName,
+  rateLimited: () => rateLimited,
   removeApprovalListener: () => removeApprovalListener,
   requestApproval: () => requestApproval,
   resolveApproval: () => resolveApproval,
@@ -54,24 +57,16 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/schema.ts
+var import_zod = require("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 = import_zod.z.toJSONSchema(standardSchema);
+  return {
+    name,
+    schema: jsonSchema
+  };
 };
 var convertMCPSchemaToToolSchema = (mcpSchema) => {
   if (!mcpSchema?.properties) return {};
@@ -92,6 +87,10 @@ function normalizeSchema(schema, name) {
   }
   return schema;
 }
+var convertStandardSchemaToSchemaProperties = (standardSchema) => {
+  const jsonSchema = import_zod.z.toJSONSchema(standardSchema);
+  return convertMCPSchemaToToolSchema(jsonSchema);
+};
 
 // src/mcp.ts
 var createMCPTools = async (client) => {
@@ -130,9 +129,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);
@@ -198,6 +198,49 @@ var maxCalls = (toolConfig, maxCalls2) => ({
   _maxCalls: maxCalls2
 });
 
+// src/embed.ts
+var import_transformers = require("@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 (0, import_transformers.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) {
@@ -329,18 +372,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 = `
 
@@ -442,10 +533,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) {
           }
         }
@@ -459,7 +557,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,
@@ -681,7 +779,7 @@ var model = ({
         tools: []
       }
     ) : (
-      // model()(/* few shot / history */);
+      // model()(/* few shot or history */);
       ctxOrMessage
     );
     const normalizedSchema = schema ? normalizeSchema(schema) : void 0;
@@ -712,27 +810,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",
@@ -793,7 +876,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: [
@@ -1122,6 +1249,59 @@ 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();
+    });
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Inherit,
@@ -1129,7 +1309,9 @@ var scope = (config, ...steps) => {
   compose,
   convertMCPSchemaToToolSchema,
   convertStandardSchemaToJsonSchema,
+  convertStandardSchemaToSchemaProperties,
   createMCPTools,
+  embed,
   everyNMessages,
   everyNTokens,
   generateApprovalToken,
@@ -1143,6 +1325,7 @@ var scope = (config, ...steps) => {
   onApprovalRequested,
   onApprovalResolved,
   parseModelName,
+  rateLimited,
   removeApprovalListener,
   requestApproval,
   resolveApproval,