@absolutejs/ai 0.0.24 → 0.0.26

package/dist/ai/index.js

@@ -292,12 +292,7 @@ var EFFORT_ORDER = [
   "high",
   "max"
 ];
-var ANTHROPIC_EFFORT = [
-  /opus-4-[5-8]/,
-  /sonnet-4-6/,
-  /fable-5/,
-  /mythos-5/
-];
+var ANTHROPIC_EFFORT = [/opus-4-[5-8]/, /sonnet-4-6/, /fable-5/, /mythos-5/];
 var ANTHROPIC_ADAPTIVE_ONLY = [];
 var ANTHROPIC_LEGACY_THINKING = [
   /sonnet-4-5/,
@@ -1526,7 +1521,7 @@ var gemini = (config2) => {
 var h2IfHttps4 = (url) => url.startsWith("https://") ? { protocol: "http2" } : {};
 var DEFAULT_BASE_URL4 = "https://api.anthropic.com";
 var API_VERSION = "2023-06-01";
-var MAX_TOKENS = 8192;
+var DEFAULT_MAX_TOKENS = 32000;
 var EVENT_PREFIX_LENGTH2 = 7;
 var DATA_PREFIX_LENGTH2 = 6;
 var EMPTY_CHUNKS = [];
@@ -1577,16 +1572,42 @@ var mapToolDefinition2 = (tool) => ({
   input_schema: tool.input_schema,
   name: tool.name
 });
-var buildRequestBody4 = (params) => {
+var cacheLastContentBlock = (msg) => {
+  const cacheControl = { type: "ephemeral" };
+  if (typeof msg.content === "string") {
+    return {
+      content: [
+        { cache_control: cacheControl, text: msg.content, type: "text" }
+      ],
+      role: msg.role
+    };
+  }
+  if (msg.content.length === 0)
+    return msg;
+  const blocks = [...msg.content];
+  blocks[blocks.length - 1] = {
+    ...blocks[blocks.length - 1],
+    cache_control: cacheControl
+  };
+  return { content: blocks, role: msg.role };
+};
+var buildRequestBody4 = (params, configuredMax, promptCaching) => {
   const messages = params.messages.filter((msg) => msg.role !== "system").map(mapMessage);
+  if (promptCaching && messages.length > 1) {
+    const last = messages[messages.length - 1];
+    if (last) {
+      messages[messages.length - 1] = cacheLastContentBlock(last);
+    }
+  }
+  const max = typeof params.maxTokens === "number" ? params.maxTokens : configuredMax;
   const body = {
-    max_tokens: MAX_TOKENS,
+    max_tokens: max,
     messages,
     model: params.model,
     stream: true
   };
   if (params.systemPrompt) {
-    body.system = params.cacheSystemPrompt ? [
+    body.system = promptCaching || params.cacheSystemPrompt ? [
       {
         cache_control: { type: "ephemeral" },
         text: params.systemPrompt,
@@ -1595,7 +1616,14 @@ var buildRequestBody4 = (params) => {
     ] : params.systemPrompt;
   }
   if (params.tools && params.tools.length > 0) {
-    body.tools = params.tools.map(mapToolDefinition2);
+    const tools = params.tools.map(mapToolDefinition2);
+    if (promptCaching) {
+      tools[tools.length - 1] = {
+        ...tools[tools.length - 1],
+        cache_control: { type: "ephemeral" }
+      };
+    }
+    body.tools = tools;
     if (params.toolChoice === "auto" || params.toolChoice === "none") {
       body.tool_choice = { type: params.toolChoice };
     } else if (params.toolChoice === "required") {
@@ -1604,8 +1632,6 @@ var buildRequestBody4 = (params) => {
       body.tool_choice = { name: params.toolChoice.name, type: "tool" };
     }
   }
-  if (typeof params.maxTokens === "number")
-    body.max_tokens = params.maxTokens;
   if (params.stopSequences && params.stopSequences.length > 0) {
     body.stop_sequences = params.stopSequences;
   }
@@ -1629,7 +1655,7 @@ var buildRequestBody4 = (params) => {
     const budget = resolveBudgetTokens(params.reasoning);
     if (budget) {
       body.thinking = { budget_tokens: budget, type: "enabled" };
-      body.max_tokens = Math.max(typeof body.max_tokens === "number" ? body.max_tokens : MAX_TOKENS, budget + MAX_TOKENS);
+      body.max_tokens = Math.max(max, budget + max);
     }
   }
   return body;
@@ -1778,6 +1804,10 @@ var extractUsage4 = (usageRecord, existingUsage) => {
 var handleMessageDelta = (parsed, state) => {
   const deltaUsage = getRecord(parsed, "usage");
   state.usage = extractUsage4(deltaUsage, state.usage);
+  const delta = getRecord(parsed, "delta");
+  const stopReason = delta ? getString(delta, "stop_reason") : "";
+  if (stopReason)
+    state.stopReason = stopReason;
 };
 var handleMessageStart = (parsed, state) => {
   const message = getRecord(parsed, "message");
@@ -1820,7 +1850,11 @@ var processEvent = (eventType, parsed, state) => {
       return;
     }
     case "message_stop": {
-      return { type: "done", usage: state.usage };
+      return {
+        stopReason: state.stopReason,
+        type: "done",
+        usage: state.usage
+      };
     }
     case "error": {
       handleError(parsed);
@@ -1896,6 +1930,7 @@ async function* parseSSEStream4(body, signal) {
     currentToolId: "",
     currentToolName: "",
     isThinkingBlock: false,
+    stopReason: "",
     thinkingSignature: "",
     toolInputJson: "",
     usage: undefined
@@ -1906,8 +1941,8 @@ async function* parseSSEStream4(body, signal) {
     reader.releaseLock();
   }
 }
-var fetchAndStream = async function* (baseUrl, config2, params) {
-  const body = buildRequestBody4(params);
+var fetchAndStream = async function* (baseUrl, config2, params, configuredMax, promptCaching) {
+  const body = buildRequestBody4(params, configuredMax, promptCaching);
   const target = `${baseUrl}/v1/messages`;
   const response = await fetch(target, {
     ...h2IfHttps4(target),
@@ -1935,8 +1970,10 @@ var fetchAndStream = async function* (baseUrl, config2, params) {
 };
 var anthropic = (config2) => {
   const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL4;
+  const configuredMax = config2.maxTokens ?? DEFAULT_MAX_TOKENS;
+  const promptCaching = config2.promptCaching ?? true;
   return instrumentAIProvider({
-    stream: (params) => fetchAndStream(baseUrl, config2, params)
+    stream: (params) => fetchAndStream(baseUrl, config2, params, configuredMax, promptCaching)
   }, "anthropic");
 };
 
@@ -2672,6 +2709,42 @@ var handleStreamError = async (socket, err, messageId, conversationId, signal, s
 
 // src/ai/streamAIToSSE.ts
 var DEFAULT_MAX_TURNS2 = 10;
+var DEFAULT_HEARTBEAT_MS = 15000;
+var HEARTBEAT_TICK = Symbol("heartbeat-tick");
+var withHeartbeat = async function* (source, signal, intervalMs) {
+  if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+    yield* source;
+    return;
+  }
+  try {
+    let next = source.next();
+    for (;; ) {
+      let timer;
+      const tick = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(HEARTBEAT_TICK), intervalMs);
+      });
+      let winner;
+      try {
+        winner = await Promise.race([next, tick]);
+      } finally {
+        if (timer)
+          clearTimeout(timer);
+      }
+      if (winner === HEARTBEAT_TICK) {
+        if (signal.aborted)
+          return;
+        yield { data: "", event: "ping" };
+        continue;
+      }
+      if (winner.done)
+        return;
+      yield winner.value;
+      next = source.next();
+    }
+  } finally {
+    await source.return?.(undefined);
+  }
+};
 var buildToolDefinitions2 = (tools) => Object.entries(tools).map(([name, def]) => ({
   description: def.description,
   input_schema: def.input,
@@ -2695,7 +2768,7 @@ var streamAIToSSE = async function* (conversationId, messageId, options, rendere
   const maxTurns = options.maxTurns ?? DEFAULT_MAX_TURNS2;
   const messages = options.messages ? [...options.messages] : [];
   try {
-    yield* streamTurns(options, renderers, messages, signal, startTime, maxTurns);
+    yield* withHeartbeat(streamTurns(options, renderers, messages, signal, startTime, maxTurns), signal, options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS);
   } catch (err) {
     if (signal.aborted)
       return;
@@ -2790,9 +2863,21 @@ var processChunk2 = function* (chunk, chunkState, renderers, options, fullRespon
     case "done":
       maybeFlushThinking(chunkState);
       chunkState.usage = chunk.usage;
+      chunkState.stopReason = chunk.stopReason;
       break;
   }
 };
+var truncateToolResult = (result, max) => {
+  if (result.length <= max)
+    return result;
+  const omitted = result.length - max;
+  const headLen = Math.ceil(max / 2);
+  const tailLen = max - headLen;
+  const marker = `
+<result truncated to ${max} chars; ${omitted} omitted \u2014 re-read a narrower slice if needed>
+`;
+  return result.slice(0, headLen) + marker + result.slice(result.length - tailLen);
+};
 var executeToolCalls = async function* (pendingToolCalls, options, renderers, turnState) {
   const toolResultBlocks = [];
   for (const toolCall of pendingToolCalls) {
@@ -2802,8 +2887,9 @@ var executeToolCalls = async function* (pendingToolCalls, options, renderers, tu
     turnState.allToolsHtml = turnState.allToolsHtml.replace(renderers.toolRunning(toolCall.name, toolCall.input), renderers.toolComplete(toolCall.name, result));
     yield { data: turnState.allToolsHtml, event: "tools" };
     options.onToolUse?.(toolCall.name, toolCall.input, result);
+    const resultContent = options.maxToolResultChars !== undefined ? truncateToolResult(result, options.maxToolResultChars) : result;
     toolResultBlocks.push({
-      content: result,
+      content: resultContent,
       tool_use_id: toolCall.id,
       type: "tool_result"
     });
@@ -2848,14 +2934,17 @@ var streamTurns = async function* (options, renderers, messages, signal, startTi
     turn: 0
   };
   const toolDefs = options.tools ? buildToolDefinitions2(options.tools) : undefined;
+  let runningTotalTokens = 0;
   for (;turnState.turn <= maxTurns && !signal.aborted; turnState.turn++) {
     const chunkState = {
       contentBlocks: [],
       currentThinking: null,
       pendingToolCalls: [],
+      stopReason: undefined,
       usage: undefined
     };
     const stream = options.provider.stream({
+      maxTokens: options.maxTokens,
       messages: turnState.currentMessages,
       model: options.model,
       reasoning: options.reasoning,
@@ -2864,6 +2953,29 @@ var streamTurns = async function* (options, renderers, messages, signal, startTi
       tools: toolDefs
     });
     yield* consumeStream2(stream, chunkState, renderers, options, turnState, signal);
+    options.onTurn?.(turnState.turn, chunkState.usage);
+    runningTotalTokens += (chunkState.usage?.inputTokens ?? 0) + (chunkState.usage?.outputTokens ?? 0);
+    if (chunkState.stopReason === "max_tokens") {
+      yield {
+        data: renderers.error(`Response truncated at max_tokens (output=${chunkState.usage?.outputTokens ?? "?"}). ` + `Raise maxTokens on the provider/options, split the request, or reduce upstream context.`),
+        event: "status"
+      };
+      return;
+    }
+    if (options.maxTotalTokens && runningTotalTokens >= options.maxTotalTokens) {
+      yield {
+        data: renderers.error(`Stopped: token budget reached (${runningTotalTokens}/${options.maxTotalTokens} tokens over ` + `${turnState.turn} turns). Narrow the request or raise maxTotalTokens.`),
+        event: "status"
+      };
+      return;
+    }
+    if (options.maxDurationMs && Date.now() - startTime >= options.maxDurationMs) {
+      yield {
+        data: renderers.error(`Stopped: time budget reached (${Math.round((Date.now() - startTime) / 1000)}s over ` + `${turnState.turn} turns). Narrow the request or raise maxDurationMs.`),
+        event: "status"
+      };
+      return;
+    }
     if (shouldStopToolLoop(chunkState, turnState, signal)) {
       return void (yield yieldCompletion(renderers, options, turnState.fullResponse, chunkState.usage, startTime));
     }
@@ -3253,7 +3365,12 @@ var toProviderTools = (tools) => Object.entries(tools).map(([name, definition])
   name
 }));
 var generateAIWithTools = async (options) => {
-  const { maxTurns = DEFAULT_TOOL_MAX_TURNS, onToolUse, tools, ...base } = options;
+  const {
+    maxTurns = DEFAULT_TOOL_MAX_TURNS,
+    onToolUse,
+    tools,
+    ...base
+  } = options;
   const providerTools = toProviderTools(tools);
   const toolCalls = [];
   let usage;
@@ -4283,5 +4400,5 @@ export {
   PROVIDER_STATUS_PAGES
 };
 
-//# debugId=E077A15D83F1F94464756E2164756E21
+//# debugId=90792F1972AEBAA464756E2164756E21
 //# sourceMappingURL=index.js.map