@absolutejs/ai 0.0.28 → 0.0.30

package/dist/ai/index.js

@@ -3432,6 +3432,7 @@ var generateAIWithTools = async (options) => {
   };
   return runTurn(options.messages, maxTurns);
 };
+var DEFAULT_OBJECT_REPAIR_ATTEMPTS = 1;
 var generateObjectAI = async (options) => {
   const toolName = options.toolName ?? DEFAULT_OBJECT_TOOL_NAME;
   const tool = {
@@ -3439,26 +3440,218 @@ var generateObjectAI = async (options) => {
     input_schema: options.schema,
     name: toolName
   };
-  const { toolCalls, usage } = await generateAI({
-    cacheSystemPrompt: options.cacheSystemPrompt,
-    maxTokens: options.maxTokens,
-    messages: options.messages,
-    model: options.model,
-    promptCaching: options.promptCaching,
-    provider: options.provider,
-    reasoning: options.reasoning,
-    signal: options.signal,
-    systemPrompt: options.systemPrompt,
-    temperature: options.temperature,
-    toolChoice: { name: toolName },
-    tools: [tool]
+  const maxRepairAttempts = Math.max(0, options.maxRepairAttempts ?? DEFAULT_OBJECT_REPAIR_ATTEMPTS);
+  const messages = [...options.messages];
+  let usage;
+  let lastError;
+  for (let attempt = 0;attempt <= maxRepairAttempts; attempt += 1) {
+    const result = await generateAI({
+      cacheSystemPrompt: options.cacheSystemPrompt,
+      maxTokens: options.maxTokens,
+      messages,
+      model: options.model,
+      promptCaching: options.promptCaching,
+      provider: options.provider,
+      reasoning: options.reasoning,
+      signal: options.signal,
+      systemPrompt: options.systemPrompt,
+      temperature: options.temperature,
+      toolChoice: { name: toolName },
+      tools: [tool]
+    });
+    usage = mergeUsage(usage, result.usage);
+    const call = result.toolCalls.find((toolCall) => toolCall.name === toolName);
+    let failure;
+    let object;
+    if (!call) {
+      lastError = new Error(`generateObjectAI: model did not call the "${toolName}" tool`);
+      failure = `You did not call the "${toolName}" tool. Call it exactly once with the structured result.`;
+    } else {
+      try {
+        object = options.validate ? options.validate(call.input) : call.input;
+      } catch (error) {
+        lastError = error;
+        failure = `Your "${toolName}" output failed validation: ${error instanceof Error ? error.message : String(error)}. Call "${toolName}" again with corrected output that satisfies the schema.`;
+      }
+    }
+    if (failure === undefined)
+      return { object, usage };
+    if (attempt >= maxRepairAttempts)
+      break;
+    if (call) {
+      messages.push({
+        content: [
+          {
+            id: call.id,
+            input: call.input && typeof call.input === "object" ? call.input : {},
+            name: toolName,
+            type: "tool_use"
+          }
+        ],
+        role: "assistant"
+      }, {
+        content: [
+          { content: failure, tool_use_id: call.id, type: "tool_result" }
+        ],
+        role: "user"
+      });
+    } else {
+      messages.push({ content: failure, role: "user" });
+    }
+  }
+  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"
   });
-  const call = toolCalls.find((toolCall) => toolCall.name === toolName);
-  if (!call) {
-    throw new Error(`generateObjectAI: model did not call the "${toolName}" tool`);
+  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)}`
+    };
   }
-  const object = options.validate ? options.validate(call.input) : call.input;
-  return { object, usage };
+};
+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;
@@ -4381,6 +4574,7 @@ var startProviderStatusMonitor = (options) => {
 export {
   xai,
   withResilience,
+  streamAIWithTools,
   streamAIToSSE,
   streamAI,
   startProviderStatusMonitor,
@@ -4420,5 +4614,5 @@ export {
   PROVIDER_STATUS_PAGES
 };
 
-//# debugId=CE76A2131808230464756E2164756E21
+//# debugId=488D46E6DE9AC4E164756E2164756E21
 //# sourceMappingURL=index.js.map