@absolutejs/ai 0.0.29 → 0.0.30

package/dist/ai/index.js

@@ -3501,6 +3501,158 @@ var generateObjectAI = async (options) => {
   }
   throw lastError instanceof Error ? lastError : new Error(`generateObjectAI: failed to produce valid output`);
 };
+
+// src/ai/streamAIWithTools.ts
+var DEFAULT_STREAM_TOOL_MAX_TURNS = 8;
+var toolCallKey = (call) => `${call.name}:${JSON.stringify(call.input)}`;
+var pushText = (blocks, content) => {
+  const last = blocks[blocks.length - 1];
+  if (last && last.type === "text") {
+    last.content += content;
+    return;
+  }
+  blocks.push({ content, type: "text" });
+};
+var flushThinking3 = (blocks, thinking) => {
+  if (!thinking)
+    return null;
+  blocks.push({
+    signature: thinking.signature || undefined,
+    thinking: thinking.text,
+    type: "thinking"
+  });
+  return null;
+};
+var executeToolHandler = async (tools, call) => {
+  const definition = tools[call.name];
+  if (!definition) {
+    return { ok: false, result: `Error: unknown tool "${call.name}"` };
+  }
+  try {
+    return { ok: true, result: await definition.handler(call.input) };
+  } catch (err) {
+    return {
+      ok: false,
+      result: `Error: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+};
+var streamAIWithTools = async function* (options) {
+  const {
+    maxTurns = DEFAULT_STREAM_TOOL_MAX_TURNS,
+    provider,
+    toolChoice,
+    tools,
+    ...base
+  } = options;
+  const providerTools = toProviderTools(tools);
+  const allToolCalls = [];
+  const executedKeys = new Set;
+  const messages = [...options.messages];
+  let usage;
+  let fullText = "";
+  let turn = 0;
+  const streamOneTurn = async function* () {
+    const stream = provider.stream({
+      cacheSystemPrompt: base.cacheSystemPrompt,
+      maxTokens: base.maxTokens,
+      messages,
+      model: base.model,
+      promptCaching: base.promptCaching,
+      reasoning: base.reasoning,
+      signal: base.signal,
+      stopSequences: base.stopSequences,
+      systemPrompt: base.systemPrompt,
+      temperature: base.temperature,
+      toolChoice: toolChoice ?? "auto",
+      tools: providerTools,
+      topP: base.topP
+    });
+    const blocks = [];
+    const pending = [];
+    let thinking = null;
+    let turnUsage;
+    for await (const chunk of stream) {
+      if (base.signal?.aborted)
+        break;
+      if (chunk.type === "thinking") {
+        if (chunk.content)
+          yield { content: chunk.content, type: "thinking" };
+        thinking = thinking ?? { signature: "", text: "" };
+        thinking.text += chunk.content;
+        if (chunk.signature)
+          thinking.signature = chunk.signature;
+      } else if (chunk.type === "text") {
+        thinking = flushThinking3(blocks, thinking);
+        fullText += chunk.content;
+        pushText(blocks, chunk.content);
+        yield { content: chunk.content, type: "text" };
+      } else if (chunk.type === "tool_use") {
+        thinking = flushThinking3(blocks, thinking);
+        pending.push({ id: chunk.id, input: chunk.input, name: chunk.name });
+        blocks.push({
+          id: chunk.id,
+          input: chunk.input && typeof chunk.input === "object" ? chunk.input : {},
+          name: chunk.name,
+          type: "tool_use"
+        });
+      } else if (chunk.type === "done") {
+        thinking = flushThinking3(blocks, thinking);
+        turnUsage = chunk.usage;
+      }
+    }
+    thinking = flushThinking3(blocks, thinking);
+    return { blocks, pending, usage: turnUsage };
+  };
+  while (turn < maxTurns) {
+    turn += 1;
+    const outcome = yield* streamOneTurn();
+    usage = mergeUsage(usage, outcome.usage);
+    yield { type: "turn", usage: outcome.usage };
+    const { blocks, pending } = outcome;
+    allToolCalls.push(...pending);
+    const allRepeats = pending.length > 0 && pending.every((call) => executedKeys.has(toolCallKey(call)));
+    const finished = pending.length === 0 || turn >= maxTurns || allRepeats || base.signal?.aborted === true;
+    if (finished)
+      break;
+    messages.push({ content: blocks, role: "assistant" });
+    const resultBlocks = [];
+    for (const call of pending) {
+      yield {
+        id: call.id,
+        input: call.input,
+        name: call.name,
+        type: "tool_start"
+      };
+      const startedAt = Date.now();
+      const { ok, result } = await executeToolHandler(tools, call);
+      executedKeys.add(toolCallKey(call));
+      yield {
+        id: call.id,
+        input: call.input,
+        ms: Date.now() - startedAt,
+        name: call.name,
+        ok,
+        result,
+        type: "tool_result"
+      };
+      resultBlocks.push({
+        content: result,
+        tool_use_id: call.id,
+        type: "tool_result"
+      });
+    }
+    messages.push({ content: resultBlocks, role: "user" });
+  }
+  const summary = {
+    text: fullText,
+    toolCalls: allToolCalls,
+    turns: turn,
+    usage
+  };
+  yield { ...summary, type: "done" };
+  return summary;
+};
 // src/ai/conversationManager.ts
 var NOT_FOUND3 = -1;
 var TITLE_MAX_LENGTH2 = 80;
@@ -4422,6 +4574,7 @@ var startProviderStatusMonitor = (options) => {
 export {
   xai,
   withResilience,
+  streamAIWithTools,
   streamAIToSSE,
   streamAI,
   startProviderStatusMonitor,
@@ -4461,5 +4614,5 @@ export {
   PROVIDER_STATUS_PAGES
 };
 
-//# debugId=AAB25EB53BF9BE9064756E2164756E21
+//# debugId=488D46E6DE9AC4E164756E2164756E21
 //# sourceMappingURL=index.js.map