@threaded/ai 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Inherit: () => Inherit,
+  appendToLastRequest: () => appendToLastRequest,
+  compose: () => compose,
+  convertMCPSchemaToToolSchema: () => convertMCPSchemaToToolSchema,
+  convertStandardSchemaToJsonSchema: () => convertStandardSchemaToJsonSchema,
+  createMCPTools: () => createMCPTools,
+  everyNMessages: () => everyNMessages,
+  everyNTokens: () => everyNTokens,
+  generateApprovalToken: () => generateApprovalToken,
+  getOrCreateThread: () => getOrCreateThread,
+  isStandardSchema: () => isStandardSchema,
+  model: () => model,
+  noToolsCalled: () => noToolsCalled,
+  normalizeSchema: () => normalizeSchema,
+  onApprovalRequested: () => onApprovalRequested,
+  onApprovalResolved: () => onApprovalResolved,
+  removeApprovalListener: () => removeApprovalListener,
+  requestApproval: () => requestApproval,
+  resolveApproval: () => resolveApproval,
+  retry: () => retry,
+  scope: () => scope,
+  tap: () => tap,
+  toolNotUsedInNTurns: () => toolNotUsedInNTurns,
+  toolWasCalled: () => toolWasCalled,
+  when: () => when
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/schema.ts
+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."
+  );
+};
+var convertMCPSchemaToToolSchema = (mcpSchema) => {
+  if (!mcpSchema?.properties) return {};
+  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)
+    };
+  }
+  return result;
+};
+function normalizeSchema(schema, name) {
+  if (isStandardSchema(schema)) {
+    return convertStandardSchemaToJsonSchema(schema, name);
+  }
+  return schema;
+}
+
+// src/mcp.ts
+var createMCPTools = async (client) => {
+  const serverInfo = client.getServerVersion();
+  const serverName = serverInfo?.name;
+  if (!serverName) {
+    console.error("MCP server has no name? Skipping tool creation.");
+    return [];
+  }
+  const toolsResponse = await client.listTools();
+  return toolsResponse.tools.map((mcpTool) => {
+    const prefixedName = `${serverName}_${mcpTool.name}`;
+    return {
+      name: prefixedName,
+      description: `[${serverName}] ${mcpTool.description || ""}`,
+      schema: convertMCPSchemaToToolSchema(mcpTool.inputSchema),
+      execute: async (args) => {
+        const result = await client.callTool({
+          name: mcpTool.name,
+          arguments: args
+        });
+        return result.content && Array.isArray(result.content) && result.content[0]?.text || JSON.stringify(result);
+      }
+    };
+  });
+};
+
+// src/types.ts
+var Inherit = /* @__PURE__ */ ((Inherit2) => {
+  Inherit2[Inherit2["Nothing"] = 0] = "Nothing";
+  Inherit2[Inherit2["Conversation"] = 1] = "Conversation";
+  Inherit2[Inherit2["Tools"] = 2] = "Tools";
+  Inherit2[Inherit2["All"] = 3] = "All";
+  return Inherit2;
+})(Inherit || {});
+
+// src/utils.ts
+var toolConfigToToolDefinition = (tool) => {
+  const properties = {};
+  const required = [];
+  for (const [key, prop] of Object.entries(tool.schema)) {
+    properties[key] = convertSchemaProperty(prop);
+    if (!prop.optional) {
+      required.push(key);
+    }
+  }
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: {
+        type: "object",
+        properties,
+        ...required.length > 0 && { required }
+      }
+    }
+  };
+};
+var convertSchemaProperty = (prop) => {
+  const result = {
+    type: prop.type
+  };
+  if (prop.description) {
+    result.description = prop.description;
+  }
+  if (prop.enum) {
+    result.enum = prop.enum;
+  }
+  if (prop.items) {
+    result.items = convertSchemaProperty(prop.items);
+  }
+  if (prop.properties) {
+    result.properties = {};
+    for (const [key, childProp] of Object.entries(prop.properties)) {
+      result.properties[key] = convertSchemaProperty(childProp);
+    }
+  }
+  return result;
+};
+var parseModelName = (model2) => {
+  const parts = model2.split("/");
+  if (parts.length === 1) {
+    return { provider: "huggingface", model: parts[0] };
+  }
+  return {
+    provider: parts[0],
+    model: parts.slice(1).join("/")
+  };
+};
+var globalKeys = {};
+var getKey = (provider) => {
+  const key = globalKeys[provider.toLowerCase()];
+  if (!key) {
+    throw new Error(`No API key configured for provider: ${provider}`);
+  }
+  return key;
+};
+
+// src/providers/openai.ts
+var callOpenAI = async (config, ctx) => {
+  const { model: model2, instructions, schema } = config;
+  const apiKey = getKey("openai") || process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OpenAI API key not found");
+  }
+  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.openai.com/v1/chat/completions", {
+    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}`);
+  }
+  if (ctx.stream) {
+    return handleOpenAIStream(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 handleOpenAIStream = async (response, ctx) => {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let fullContent = "";
+  let toolCalls = [];
+  const toolCallsBuffer = {};
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value);
+      const lines = chunk.split("\n");
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]") 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) {
+              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;
+                }
+              }
+            }
+          } catch (e) {
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  toolCalls = Object.values(toolCallsBuffer);
+  const msg = {
+    role: "assistant",
+    content: fullContent
+  };
+  if (toolCalls.length > 0) {
+    msg.tool_calls = toolCalls;
+  }
+  return {
+    ...ctx,
+    lastResponse: msg,
+    history: [...ctx.history, msg]
+  };
+};
+
+// src/providers/anthropic.ts
+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 (schema) {
+    const schemaPrompt = `
+
+You must respond with valid JSON that matches this schema:
+${JSON.stringify(
+      schema.schema,
+      null,
+      2
+    )}
+
+Return only the JSON object, no other text or formatting.`;
+    system = system ? system + schemaPrompt : schemaPrompt.slice(2);
+  }
+  const body = {
+    model: model2,
+    messages,
+    max_tokens: 4096,
+    stream: !!ctx.stream
+  };
+  if (system) {
+    body.system = system;
+  }
+  if (ctx.tools && ctx.tools.length > 0) {
+    body.tools = ctx.tools.map((tool) => ({
+      name: tool.function.name,
+      description: tool.function.description,
+      input_schema: tool.function.parameters
+    }));
+  }
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Anthropic API error: ${error}`);
+  }
+  if (ctx.stream) {
+    return handleAnthropicStream(response, ctx);
+  }
+  const data = await response.json();
+  const content = data.content[0];
+  const msg = {
+    role: "assistant",
+    content: content.type === "text" ? content.text : ""
+  };
+  if (content.type === "tool_use") {
+    msg.tool_calls = [
+      {
+        id: content.id,
+        type: "function",
+        function: {
+          name: content.name,
+          arguments: JSON.stringify(content.input)
+        }
+      }
+    ];
+  }
+  return {
+    ...ctx,
+    lastResponse: msg,
+    history: [...ctx.history, msg]
+  };
+};
+var handleAnthropicStream = async (response, ctx) => {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let fullContent = "";
+  const toolCalls = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value);
+      const lines = chunk.split("\n");
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          try {
+            const parsed = JSON.parse(data);
+            if (parsed.type === "content_block_delta" && parsed.delta?.text) {
+              fullContent += parsed.delta.text;
+              if (ctx.stream) {
+                ctx.stream({ type: "content", content: parsed.delta.text });
+              }
+            }
+            if (parsed.type === "content_block_start" && parsed.content_block?.type === "tool_use") {
+              const toolUse = parsed.content_block;
+              toolCalls.push({
+                id: toolUse.id,
+                type: "function",
+                function: {
+                  name: toolUse.name,
+                  arguments: JSON.stringify(toolUse.input)
+                }
+              });
+            }
+          } 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/google.ts
+var callGoogle = async (config, ctx) => {
+  const { model: model2, instructions } = config;
+  const apiKey = getKey("google") || process.env.GOOGLE_AI_API_KEY;
+  if (!apiKey) {
+    throw new Error("Google API key not found");
+  }
+  const contents = [];
+  if (instructions) {
+    contents.push({
+      role: "user",
+      parts: [{ text: instructions }]
+    });
+    contents.push({
+      role: "model",
+      parts: [{ text: "I understand." }]
+    });
+  }
+  for (const msg2 of ctx.history) {
+    const role = msg2.role === "assistant" ? "model" : "user";
+    contents.push({
+      role,
+      parts: [{ text: msg2.content }]
+    });
+  }
+  const body = {
+    contents
+  };
+  if (ctx.tools && ctx.tools.length > 0) {
+    body.tools = [
+      {
+        function_declarations: ctx.tools.map((tool) => ({
+          name: tool.function.name,
+          description: tool.function.description,
+          parameters: tool.function.parameters
+        }))
+      }
+    ];
+  }
+  const endpoint = ctx.stream ? "streamGenerateContent" : "generateContent";
+  const response = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model2}:${endpoint}?key=${apiKey}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    }
+  );
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Google API error: ${error}`);
+  }
+  if (ctx.stream) {
+    return handleGoogleStream(response, ctx);
+  }
+  const data = await response.json();
+  const candidate = data.candidates[0];
+  const part = candidate.content.parts[0];
+  const msg = {
+    role: "assistant",
+    content: part.text || ""
+  };
+  if (part.functionCall) {
+    msg.tool_calls = [
+      {
+        id: Math.random().toString(36).substring(2, 9),
+        type: "function",
+        function: {
+          name: part.functionCall.name,
+          arguments: JSON.stringify(part.functionCall.args)
+        }
+      }
+    ];
+  }
+  return {
+    ...ctx,
+    lastResponse: msg,
+    history: [...ctx.history, msg]
+  };
+};
+var handleGoogleStream = async (response, ctx) => {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let fullContent = "";
+  const toolCalls = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value);
+      const lines = chunk.split("\n");
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          try {
+            const parsed = JSON.parse(data);
+            const candidate = parsed.candidates?.[0];
+            const part = candidate?.content?.parts?.[0];
+            if (part?.text) {
+              fullContent += part.text;
+              if (ctx.stream) {
+                ctx.stream({ type: "content", content: part.text });
+              }
+            }
+            if (part?.functionCall) {
+              toolCalls.push({
+                id: Math.random().toString(36).substring(2, 9),
+                type: "function",
+                function: {
+                  name: part.functionCall.name,
+                  arguments: JSON.stringify(part.functionCall.args)
+                }
+              });
+            }
+          } 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/huggingface.ts
+var callHuggingFace = async (config, ctx) => {
+  throw new Error(
+    "Hugging Face provider not yet implemented. Use openai/, anthropic/, or google/ prefixes."
+  );
+};
+
+// src/providers/index.ts
+var callProvider = async (config, ctx) => {
+  const { provider, model: model2 } = parseModelName(config.model);
+  const providerConfig = { ...config, model: model2 };
+  switch (provider.toLowerCase()) {
+    case "openai":
+      return callOpenAI(providerConfig, ctx);
+    case "anthropic":
+      return callAnthropic(providerConfig, ctx);
+    case "google":
+      return callGoogle(providerConfig, ctx);
+    case "huggingface":
+    default:
+      return callHuggingFace(providerConfig, ctx);
+  }
+};
+
+// src/approval.ts
+var import_events = require("events");
+var state = {
+  resolvers: /* @__PURE__ */ new Map(),
+  emitter: new import_events.EventEmitter()
+};
+var generateApprovalToken = () => {
+  return `approval_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+};
+var requestApproval = async (toolCall, approvalId) => {
+  const id = generateApprovalToken();
+  const request = { id, toolCall, approvalId };
+  state.emitter.emit("approvalRequested", request);
+  return new Promise((resolve) => {
+    state.resolvers.set(id, resolve);
+  });
+};
+var resolveApproval = (response) => {
+  const resolver = state.resolvers.get(response.id);
+  if (!resolver) return false;
+  state.resolvers.delete(response.id);
+  resolver(response);
+  state.emitter.emit("approvalResolved", response);
+  return true;
+};
+var onApprovalRequested = (listener) => {
+  state.emitter.on("approvalRequested", listener);
+};
+var onApprovalResolved = (listener) => {
+  state.emitter.on("approvalResolved", listener);
+};
+var removeApprovalListener = (event, listener) => {
+  state.emitter.removeListener(event, listener);
+};
+
+// src/composition/model.ts
+var model = ({
+  model: model2 = "openai/gpt-4o-mini",
+  schema
+} = {}) => {
+  return async (ctxOrMessage) => {
+    const ctx = typeof ctxOrMessage === "string" ? {
+      history: [{ role: "user", content: ctxOrMessage }],
+      tools: []
+    } : ctxOrMessage;
+    const normalizedSchema = schema ? normalizeSchema(schema) : void 0;
+    const systemMessage = ctx.history.find((m) => m.role === "system");
+    const instructions = systemMessage?.content;
+    let currentCtx = ctx;
+    do {
+      currentCtx = await callProvider(
+        { model: model2, instructions, schema: normalizedSchema },
+        currentCtx
+      );
+      if (currentCtx.lastResponse?.tool_calls && currentCtx.tools?.length) {
+        currentCtx = await executeTools(currentCtx);
+      }
+    } while (currentCtx.lastResponse?.tool_calls && currentCtx.tools?.length);
+    return currentCtx;
+  };
+};
+var executeTools = async (ctx) => {
+  const calls = ctx.lastResponse?.tool_calls || [];
+  if (!calls.length) return ctx;
+  if (ctx.stream) {
+    ctx.stream({ type: "tool_calls_ready", calls });
+  }
+  const toolConfig = ctx.toolConfig || {};
+  const {
+    requireApproval = false,
+    approvalCallback,
+    parallel = false,
+    retryCount = 0,
+    approvalId
+  } = 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) {
+      if (ctx.stream) {
+        ctx.stream({ type: "tool_error", call, error: "Tool execution denied by user" });
+      }
+      return {
+        call,
+        result: { error: "Tool execution denied by user" }
+      };
+    }
+    const toolName = call.function.name;
+    const limits = ctx.toolLimits || {};
+    const maxCalls = limits[toolName];
+    const currentCount = updatedCounts[toolName] || 0;
+    if (maxCalls && currentCount >= maxCalls) {
+      const error2 = `Tool ${toolName} has reached its limit of ${maxCalls} calls`;
+      if (ctx.stream) {
+        ctx.stream({ type: "tool_error", call, error: error2 });
+      }
+      return {
+        call,
+        result: { error: error2 }
+      };
+    }
+    updatedCounts[toolName] = currentCount + 1;
+    if (ctx.stream) {
+      ctx.stream({ type: "tool_executing", call });
+    }
+    let lastError;
+    for (let i = 0; i <= retryCount; i++) {
+      try {
+        const executor = ctx.toolExecutors?.[call.function.name];
+        if (!executor) {
+          throw new Error(`Tool executor not found: ${call.function.name}`);
+        }
+        let args = {};
+        try {
+          args = call.function.arguments ? JSON.parse(call.function.arguments) : {};
+        } catch (e) {
+          throw new Error(
+            `Invalid JSON arguments for tool ${call.function.name}: ${call.function.arguments}`
+          );
+        }
+        const result = await executor(args);
+        if (ctx.stream) {
+          ctx.stream({ type: "tool_complete", call, result });
+        }
+        return { call, result };
+      } catch (e) {
+        lastError = e;
+      }
+    }
+    const error = lastError.message;
+    if (ctx.stream) {
+      ctx.stream({ type: "tool_error", call, error });
+    }
+    return { call, result: { error } };
+  };
+  const results = parallel ? await Promise.all(calls.map(runCall)) : await runCallsSequentially(calls, runCall);
+  return {
+    ...ctx,
+    history: [
+      ...ctx.history,
+      ...results.map(({ call, result }) => ({
+        role: "tool",
+        tool_call_id: call.id,
+        content: JSON.stringify(result)
+      }))
+    ],
+    toolCallCounts: updatedCounts
+  };
+};
+var runCallsSequentially = async (calls, runCall) => {
+  const results = [];
+  for (const call of calls) {
+    results.push(await runCall(call));
+  }
+  return results;
+};
+
+// src/thread.ts
+var createMemoryStore = () => {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    async get(threadId) {
+      return store.get(threadId) || [];
+    },
+    async set(threadId, messages) {
+      store.set(threadId, messages);
+    }
+  };
+};
+var createThread = (id, store) => {
+  return {
+    id,
+    store,
+    async generate(workflow) {
+      const history = await store.get(id);
+      const initialContext = {
+        history,
+        tools: [],
+        toolExecutors: {},
+        toolLimits: {},
+        toolCallCounts: {}
+      };
+      const finalContext = await workflow(initialContext);
+      await store.set(id, finalContext.history);
+      return finalContext;
+    },
+    async message(content, workflow) {
+      const history = await store.get(id);
+      const initialContext = {
+        history: [...history, { role: "user", content }],
+        tools: [],
+        toolExecutors: {},
+        toolLimits: {},
+        toolCallCounts: {}
+      };
+      const finalContext = await (workflow || model())(initialContext);
+      await store.set(id, finalContext.history);
+      return finalContext;
+    }
+  };
+};
+var defaultStore = createMemoryStore();
+var threads = /* @__PURE__ */ new Map();
+var getOrCreateThread = (id, store = defaultStore) => {
+  if (threads.has(id)) {
+    return threads.get(id);
+  }
+  const thread = createThread(id, store);
+  threads.set(id, thread);
+  return thread;
+};
+
+// src/composition/when.ts
+var when = (condition, action) => {
+  return async (ctx) => {
+    if (condition(ctx)) {
+      return await action(ctx);
+    }
+    return ctx;
+  };
+};
+
+// src/helpers.ts
+var noToolsCalled = () => (ctx) => {
+  return !ctx.lastResponse?.tool_calls || ctx.lastResponse.tool_calls.length === 0;
+};
+var everyNMessages = (n, step) => {
+  let lastTriggeredAt = 0;
+  return when(
+    (ctx) => Math.floor(ctx.history.length / n) > Math.floor(lastTriggeredAt / n),
+    async (ctx) => {
+      lastTriggeredAt = ctx.history.length;
+      return await step(ctx);
+    }
+  );
+};
+var everyNTokens = (n, step) => {
+  let lastTriggeredAt = 0;
+  return when(
+    (ctx) => {
+      const totalTokens = ctx.history.reduce(
+        (acc, msg) => acc + Math.ceil(msg.content.length / 4),
+        0
+      );
+      return Math.floor(totalTokens / n) > Math.floor(lastTriggeredAt / n);
+    },
+    async (ctx) => {
+      const totalTokens = ctx.history.reduce(
+        (acc, msg) => acc + Math.ceil(msg.content.length / 4),
+        0
+      );
+      lastTriggeredAt = totalTokens;
+      return await step(ctx);
+    }
+  );
+};
+var appendToLastRequest = (content) => {
+  return async (ctx) => {
+    let lastUserIndex = -1;
+    for (let i = ctx.history.length - 1; i >= 0; i--) {
+      if (ctx.history[i].role === "user") {
+        lastUserIndex = i;
+        break;
+      }
+    }
+    if (lastUserIndex === -1) return ctx;
+    const newHistory = [...ctx.history];
+    newHistory[lastUserIndex] = {
+      ...newHistory[lastUserIndex],
+      content: newHistory[lastUserIndex].content + content
+    };
+    return {
+      ...ctx,
+      history: newHistory
+    };
+  };
+};
+var toolNotUsedInNTurns = ({ toolName, times }, step) => {
+  let turnsSinceLastUsed = 0;
+  let lastProcessedTurn = -1;
+  return when((ctx) => {
+    const currentTurn = getCurrentTurn(ctx);
+    if (currentTurn === lastProcessedTurn) return false;
+    lastProcessedTurn = currentTurn;
+    const toolUsedInTurn = wasToolUsedInCurrentTurn(ctx, toolName);
+    if (toolUsedInTurn) {
+      turnsSinceLastUsed = 0;
+      return false;
+    } else {
+      turnsSinceLastUsed++;
+      return turnsSinceLastUsed >= times;
+    }
+  }, step);
+};
+var getCurrentTurn = (ctx) => {
+  let turns = 0;
+  for (const msg of ctx.history) {
+    if (msg.role === "user") turns++;
+  }
+  return turns;
+};
+var wasToolUsedInCurrentTurn = (ctx, toolName) => {
+  let lastUserIndex = -1;
+  for (let i = ctx.history.length - 1; i >= 0; i--) {
+    if (ctx.history[i].role === "user") {
+      lastUserIndex = i;
+      break;
+    }
+  }
+  if (lastUserIndex === -1) return false;
+  for (let i = lastUserIndex + 1; i < ctx.history.length; i++) {
+    const msg = ctx.history[i];
+    if (msg.role === "assistant" && ctx.lastResponse?.tool_calls) {
+      return ctx.lastResponse.tool_calls.some(
+        (call) => call.function.name === toolName
+      );
+    }
+  }
+  return false;
+};
+var toolWasCalled = (name) => (ctx) => {
+  return !!ctx.lastResponse?.tool_calls && ctx.lastResponse.tool_calls.some((call) => call.function.name === name);
+};
+
+// src/composition/tap.ts
+var tap = (fn) => {
+  return async (ctx) => {
+    await fn(ctx);
+    return ctx;
+  };
+};
+
+// src/composition/retry.ts
+var retry = ({ times = 3 } = {}, step) => {
+  return async (ctx) => {
+    let err;
+    for (let i = 0; i < times; i++) {
+      try {
+        return await step(ctx);
+      } catch (e) {
+        err = e;
+      }
+    }
+    throw err;
+  };
+};
+
+// src/composition/compose.ts
+var enrichContext = (ctx) => {
+  const lastUserMessage = [...ctx.history].reverse().find((msg) => msg.role === "user");
+  return {
+    ...ctx,
+    lastRequest: lastUserMessage
+  };
+};
+var compose = (...steps) => {
+  return async (ctxOrMessage) => {
+    let initialContext;
+    if (typeof ctxOrMessage === "string") {
+      initialContext = {
+        history: [{ role: "user", content: ctxOrMessage }],
+        tools: [],
+        toolExecutors: {},
+        toolLimits: {},
+        toolCallCounts: {}
+      };
+    } else {
+      initialContext = ctxOrMessage || {
+        history: [],
+        tools: [],
+        toolExecutors: {},
+        toolLimits: {},
+        toolCallCounts: {}
+      };
+    }
+    let next = enrichContext(initialContext);
+    for (const step of steps) {
+      next = await step(enrichContext(next));
+    }
+    return next;
+  };
+};
+
+// src/composition/scope.ts
+var scopeContext = (config, ctx) => {
+  const inherit = config.inherit ?? 1 /* Conversation */;
+  let scopedCtx = {
+    history: [],
+    tools: [],
+    toolExecutors: {},
+    toolLimits: {},
+    toolCallCounts: {}
+  };
+  if (inherit & 1 /* Conversation */) {
+    scopedCtx.history = ctx.history;
+    scopedCtx.lastResponse = ctx.lastResponse;
+    scopedCtx.lastRequest = ctx.lastRequest;
+  }
+  if (inherit & 2 /* Tools */) {
+    scopedCtx.tools = [...ctx.tools || []];
+    scopedCtx.toolExecutors = { ...ctx.toolExecutors || {} };
+    scopedCtx.toolLimits = { ...ctx.toolLimits || {} };
+    scopedCtx.toolCallCounts = { ...ctx.toolCallCounts || {} };
+    scopedCtx.toolConfig = ctx.toolConfig ? { ...ctx.toolConfig } : void 0;
+  }
+  scopedCtx.stream = ctx.stream;
+  if (config.tools) {
+    const toolDefinitions = config.tools.map(toolConfigToToolDefinition);
+    const toolExecutors = config.tools.reduce(
+      (acc, tool) => {
+        acc[tool.name] = tool.execute;
+        return acc;
+      },
+      {}
+    );
+    const toolLimits = config.tools.reduce(
+      (acc, tool) => {
+        if (tool._maxCalls) {
+          acc[tool.name] = tool._maxCalls;
+        }
+        return acc;
+      },
+      {}
+    );
+    scopedCtx.tools = toolDefinitions;
+    scopedCtx.toolExecutors = toolExecutors;
+    scopedCtx.toolLimits = toolLimits;
+  }
+  if (config.toolConfig) {
+    scopedCtx.toolConfig = { ...config.toolConfig };
+  }
+  if (config.system) {
+    const [first, ...rest] = scopedCtx.history;
+    if (first?.role === "system") {
+      scopedCtx.history = [{ role: "system", content: config.system }, ...rest];
+    } else {
+      scopedCtx.history = [{ role: "system", content: config.system }, ...scopedCtx.history];
+    }
+  }
+  return scopedCtx;
+};
+var scope = (config, ...steps) => {
+  return async (ctx) => {
+    let scopedCtx = scopeContext(config, ctx);
+    if (config.until) {
+      do {
+        scopedCtx = await compose(...steps)(scopedCtx);
+      } while (!config.until(scopedCtx));
+    } else {
+      scopedCtx = await compose(...steps)(scopedCtx);
+    }
+    return {
+      ...ctx,
+      history: config.silent ? ctx.history : scopedCtx.history,
+      lastResponse: config.silent ? ctx.lastResponse : scopedCtx.lastResponse,
+      lastRequest: config.silent ? ctx.lastRequest : scopedCtx.lastRequest,
+      stopReason: config.silent ? ctx.stopReason : scopedCtx.stopReason
+    };
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Inherit,
+  appendToLastRequest,
+  compose,
+  convertMCPSchemaToToolSchema,
+  convertStandardSchemaToJsonSchema,
+  createMCPTools,
+  everyNMessages,
+  everyNTokens,
+  generateApprovalToken,
+  getOrCreateThread,
+  isStandardSchema,
+  model,
+  noToolsCalled,
+  normalizeSchema,
+  onApprovalRequested,
+  onApprovalResolved,
+  removeApprovalListener,
+  requestApproval,
+  resolveApproval,
+  retry,
+  scope,
+  tap,
+  toolNotUsedInNTurns,
+  toolWasCalled,
+  when
+});
+//# sourceMappingURL=index.cjs.map