@meetsmore-oss/use-ai-server 1.9.3 → 1.9.5

package/dist/index.js

@@ -114107,6 +114107,28 @@ function applyCacheBreakpoints(messages, cacheBreakpoint, model) {
 }
 
 // src/agents/AISDKAgent.ts
+function classifyApiError(error40) {
+  let errorCode = ErrorCode.UNKNOWN_ERROR;
+  const errorMessage = error40 instanceof Error ? error40.message : "Unknown error";
+  const isAPIError = (err) => typeof err === "object" && err !== null;
+  if (isAPIError(error40)) {
+    const isOverloaded = error40.statusCode === 529 || error40.data?.error?.type === "overloaded_error" || error40.message && error40.message.toLowerCase().includes("overload");
+    if (isOverloaded) {
+      errorCode = ErrorCode.API_OVERLOADED;
+    }
+    if (error40.statusCode === 429) {
+      errorCode = ErrorCode.RATE_LIMITED;
+    }
+  }
+  return { errorCode, errorMessage };
+}
+
+class AbortError extends Error {
+  constructor() {
+    super("Run aborted by user");
+    this.name = "AbortError";
+  }
+}
 var DEFAULT_MAX_OUTPUT_TOKENS = 4096;
 var DEFAULT_MAX_STEPS = 10;
 
@@ -114141,324 +114163,397 @@ class AISDKAgent {
     await flushTelemetry();
   }
   async run(input, events) {
+    const ctx = await this.createRunContext(input);
+    this.emitRunStartEvents(ctx, events);
+    const span = this.startTelemetrySpan(ctx);
+    try {
+      this.logRunStart(ctx);
+      await this.executeStepLoop(ctx, events, span);
+      return this.finalizeRun(ctx, events, span);
+    } catch (error40) {
+      return this.handleRunError(error40, ctx, events, span);
+    }
+  }
+  async createRunContext(input) {
     const { session, runId, messages, tools, state, systemPrompt: runtimeSystemPrompt, originalInput } = input;
     if (session.tools.length === 0 && tools.length > 0) {
       session.tools = tools;
     }
     const configSystemPrompt = await this.resolveSystemPrompt();
     const staticSystemMessages = this.buildStaticSystemMessages(configSystemPrompt, runtimeSystemPrompt);
+    const sanitizedInputMessages = this.sanitizeMessages(messages);
+    return {
+      session,
+      runId,
+      messages,
+      tools,
+      state,
+      originalInput,
+      staticSystemMessages,
+      streamTextStarted: false,
+      finalText: "",
+      currentStepNumber: 0,
+      hasAnyContent: false,
+      currentMessages: [...sanitizedInputMessages],
+      allResponseMessages: [],
+      response: null,
+      lastStepHadToolCalls: false
+    };
+  }
+  emitRunStartEvents(ctx, events) {
     events.emit({
       type: export_EventType.RUN_STARTED,
-      threadId: session.threadId,
-      runId,
-      input: originalInput,
+      threadId: ctx.session.threadId,
+      runId: ctx.runId,
+      input: ctx.originalInput,
       timestamp: Date.now()
     });
     events.emit({
       type: export_EventType.MESSAGES_SNAPSHOT,
-      messages: originalInput.messages,
+      messages: ctx.originalInput.messages,
       timestamp: Date.now()
     });
     events.emit({
       type: export_EventType.STATE_SNAPSHOT,
-      snapshot: state,
+      snapshot: ctx.state,
       timestamp: Date.now()
     });
-    let streamTextStarted = false;
-    const span = startRunSpan({ runId, sessionId: session.clientId });
-    const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
+  }
+  startTelemetrySpan(ctx) {
+    const span = startRunSpan({ runId: ctx.runId, sessionId: ctx.session.clientId });
+    const lastUserMessage = [...ctx.messages].reverse().find((m) => m.role === "user");
     if (lastUserMessage) {
       span.setInput(lastUserMessage.content);
     }
-    try {
-      logger2.info("Sending to AI SDK model (streaming)", {
-        clientId: session.clientId,
-        messageCount: messages.length,
-        toolCount: tools.length
-      });
-      const sanitizedInputMessages = this.sanitizeMessages(messages);
-      let currentMessages = [...sanitizedInputMessages];
-      logger2.apiRequest({
-        tools: tools.map((t) => t.name),
-        messageCount: messages.length,
-        messages: messages.map((msg) => ({
-          role: msg.role,
-          preview: typeof msg.content === "string" ? msg.content.substring(0, 80) + (msg.content.length > 80 ? "..." : "") : Array.isArray(msg.content) ? `${msg.content.length} content blocks` : "complex content"
-        })),
-        systemMessages: staticSystemMessages?.map((m) => m.content.substring(0, 80) + (m.content.length > 80 ? "..." : ""))
-      });
-      let messageId = null;
-      let hasEmittedTextStart = false;
-      let finalText = "";
-      let currentStepNumber = 0;
-      let hasAnyContent = false;
-      let response = null;
-      const allResponseMessages = [];
-      for (let stepIteration = 0;stepIteration < this.maxSteps; stepIteration++) {
-        const currentTools = session.tools;
-        logger2.debug("Starting step iteration", {
+    return span;
+  }
+  logRunStart(ctx) {
+    logger2.info("Sending to AI SDK model (streaming)", {
+      clientId: ctx.session.clientId,
+      messageCount: ctx.messages.length,
+      toolCount: ctx.tools.length
+    });
+    logger2.apiRequest({
+      tools: ctx.tools.map((t) => t.name),
+      messageCount: ctx.messages.length,
+      messages: ctx.messages.map((msg) => ({
+        role: msg.role,
+        preview: typeof msg.content === "string" ? msg.content.substring(0, 80) + (msg.content.length > 80 ? "..." : "") : Array.isArray(msg.content) ? `${msg.content.length} content blocks` : "complex content"
+      })),
+      systemMessages: ctx.staticSystemMessages?.map((m) => m.content.substring(0, 80) + (m.content.length > 80 ? "..." : ""))
+    });
+  }
+  async executeStepLoop(ctx, events, span) {
+    for (let stepIteration = 0;stepIteration <= this.maxSteps; stepIteration++) {
+      const isGracefulSummaryStep = stepIteration === this.maxSteps;
+      if (isGracefulSummaryStep && !ctx.lastStepHadToolCalls)
+        break;
+      const stepCtx = {
+        currentTools: ctx.session.tools,
+        activeToolCalls: new Map,
+        completedToolCalls: new Set,
+        stepHadToolCalls: false,
+        messageId: null,
+        hasEmittedTextStart: false,
+        stepFinishReason: undefined
+      };
+      const stateMessage = this.buildStateMessage(ctx.session.state);
+      const messagesForStep = [
+        ...ctx.staticSystemMessages || [],
+        ...stateMessage ? [stateMessage] : [],
+        ...ctx.currentMessages
+      ];
+      const stepConfig = {
+        messages: messagesForStep,
+        tools: stepCtx.currentTools.length > 0 ? this.sanitizeToolsForAPI(this.filterTools(stepCtx.currentTools), ctx.session, events) : undefined,
+        metadata: {
+          sessionId: ctx.session.clientId,
+          threadId: ctx.session.threadId,
+          runId: ctx.runId,
+          ipAddress: ctx.session.ipAddress,
+          toolCount: stepCtx.currentTools.length,
           stepIteration,
-          toolCount: currentTools.length,
-          toolNames: currentTools.map((t) => t.name)
+          ...ctx.originalInput.forwardedProps?.telemetryMetadata || {}
+        }
+      };
+      this.applyGracefulSummaryOverrides(isGracefulSummaryStep, stepConfig);
+      logger2.debug("Starting step iteration", { stepIteration, ...stepConfig.metadata });
+      const messagesWithCache = applyCacheBreakpoints(stepConfig.messages, this.cacheBreakpoint, this.model);
+      ctx.streamTextStarted = true;
+      const createStream = () => streamText({
+        model: this.model,
+        messages: messagesWithCache,
+        tools: stepConfig.tools,
+        stopWhen: stepCountIs(1),
+        maxOutputTokens: this.maxOutputTokens,
+        temperature: this.temperature,
+        abortSignal: ctx.session.abortController?.signal,
+        experimental_telemetry: span.active ? { isEnabled: true, functionId: "use-ai", metadata: stepConfig.metadata } : undefined,
+        onStepFinish: ({ usage, finishReason }) => {
+          logger2.debug("Step finished", { usage, finishReason, stepIteration });
+        }
+      });
+      const stream = span.wrap(createStream);
+      for await (const chunk of stream.fullStream) {
+        this.processStreamChunk(chunk, ctx, stepCtx, events);
+      }
+      if (ctx.session.abortController?.signal.aborted) {
+        span.endWithError("Run aborted by user");
+        events.emit({
+          type: export_EventType.RUN_ERROR,
+          message: "Run aborted by user",
+          timestamp: Date.now()
         });
-        const stateMessage = this.buildStateMessage(session.state);
-        const messagesForStep = [
-          ...staticSystemMessages || [],
-          ...stateMessage ? [stateMessage] : [],
-          ...currentMessages
-        ];
-        const messagesWithCache = applyCacheBreakpoints(messagesForStep, this.cacheBreakpoint, this.model);
-        streamTextStarted = true;
-        const createStream = () => streamText({
-          model: this.model,
-          messages: messagesWithCache,
-          tools: currentTools.length > 0 ? this.sanitizeToolsForAPI(this.filterTools(currentTools), session, events) : undefined,
-          stopWhen: stepCountIs(1),
-          maxOutputTokens: this.maxOutputTokens,
-          temperature: this.temperature,
-          abortSignal: session.abortController?.signal,
-          experimental_telemetry: span.active ? {
-            isEnabled: true,
-            functionId: "use-ai",
-            metadata: {
-              sessionId: session.clientId,
-              threadId: session.threadId,
-              runId,
-              ipAddress: session.ipAddress,
-              toolCount: currentTools.length,
-              stepIteration,
-              ...originalInput.forwardedProps?.telemetryMetadata || {}
-            }
-          } : undefined,
-          onStepFinish: ({ usage, finishReason }) => {
-            logger2.debug("Step finished", { usage, finishReason, stepIteration });
-          }
+        throw new AbortError;
+      }
+      const response = await stream.response;
+      ctx.response = response;
+      const stepMessages = this.sanitizeMessages(response.messages);
+      ctx.allResponseMessages.push(...stepMessages);
+      ctx.currentMessages = [...ctx.currentMessages, ...stepMessages];
+      if (this.handleIncompleteToolCalls(ctx, stepCtx)) {
+        continue;
+      }
+      ctx.lastStepHadToolCalls = stepCtx.stepHadToolCalls;
+      if (!stepCtx.stepHadToolCalls) {
+        logger2.debug("Step had no tool calls, finishing run", { stepIteration });
+        break;
+      }
+      logger2.debug("Continuing to next step after tool calls", {
+        stepIteration,
+        newMessageCount: ctx.currentMessages.length,
+        updatedToolCount: ctx.session.tools.length
+      });
+    }
+  }
+  handleIncompleteToolCalls(ctx, stepCtx) {
+    const incompleteToolCalls = [...stepCtx.activeToolCalls.entries()].filter(([id]) => !stepCtx.completedToolCalls.has(id)).map(([id, call]) => ({ id, ...call }));
+    const recoveryMessages = buildRecoveryToolResults(incompleteToolCalls, stepCtx.stepFinishReason, this.maxOutputTokens);
+    if (recoveryMessages.length === 0) {
+      return false;
+    }
+    const sanitized = this.sanitizeMessages(recoveryMessages);
+    ctx.allResponseMessages.push(...sanitized);
+    ctx.currentMessages = [...ctx.currentMessages, ...sanitized];
+    logger2.warn("Incomplete tool calls detected (likely maxOutputTokens exceeded)", {
+      incompleteCount: incompleteToolCalls.length
+    });
+    return true;
+  }
+  processStreamChunk(chunk, ctx, stepCtx, events) {
+    switch (chunk.type) {
+      case "start-step": {
+        events.emit({
+          type: export_EventType.STEP_STARTED,
+          stepName: `step-${ctx.currentStepNumber++}`,
+          timestamp: Date.now()
         });
-        const stream = span.wrap(createStream);
-        const activeToolCalls = new Map;
-        let stepHadToolCalls = false;
-        for await (const chunk of stream.fullStream) {
-          switch (chunk.type) {
-            case "start-step": {
-              events.emit({
-                type: export_EventType.STEP_STARTED,
-                stepName: `step-${currentStepNumber++}`,
-                timestamp: Date.now()
-              });
-              break;
-            }
-            case "text-delta": {
-              hasAnyContent = true;
-              if (!hasEmittedTextStart) {
-                messageId = v4_default();
-                events.emit({
-                  type: export_EventType.TEXT_MESSAGE_START,
-                  messageId,
-                  role: "assistant",
-                  timestamp: Date.now()
-                });
-                hasEmittedTextStart = true;
-              }
-              events.emit({
-                type: export_EventType.TEXT_MESSAGE_CONTENT,
-                messageId,
-                delta: chunk.text,
-                timestamp: Date.now()
-              });
-              finalText += chunk.text;
-              break;
-            }
-            case "reasoning-delta": {
-              logger2.debug("Reasoning", { text: chunk.text });
-              break;
-            }
-            case "tool-input-start": {
-              hasAnyContent = true;
-              stepHadToolCalls = true;
-              const toolDef = currentTools.find((t) => t.name === chunk.toolName);
-              const annotations = getToolAnnotations(toolDef);
-              const toolCallStartEvent = {
-                type: export_EventType.TOOL_CALL_START,
-                toolCallId: chunk.id,
-                toolCallName: chunk.toolName,
-                parentMessageId: messageId ?? v4_default(),
-                timestamp: Date.now()
-              };
-              if (annotations) {
-                toolCallStartEvent.annotations = annotations;
-              }
-              events.emit(toolCallStartEvent);
-              activeToolCalls.set(chunk.id, { name: chunk.toolName, args: "" });
-              break;
-            }
-            case "tool-input-delta": {
-              const toolCall = activeToolCalls.get(chunk.id);
-              if (toolCall) {
-                toolCall.args += chunk.delta;
-                events.emit({
-                  type: export_EventType.TOOL_CALL_ARGS,
-                  toolCallId: chunk.id,
-                  delta: chunk.delta,
-                  timestamp: Date.now()
-                });
-              }
-              break;
-            }
-            case "tool-call": {
-              stepHadToolCalls = true;
-              const toolCall = activeToolCalls.get(chunk.toolCallId);
-              const finalArgs = JSON.stringify(chunk.input);
-              if (toolCall && toolCall.args.length === 0) {
-                events.emit({
-                  type: export_EventType.TOOL_CALL_ARGS,
-                  toolCallId: chunk.toolCallId,
-                  delta: finalArgs,
-                  timestamp: Date.now()
-                });
-                toolCall.args = finalArgs;
-              }
-              events.emit({
-                type: export_EventType.TOOL_CALL_END,
-                toolCallId: chunk.toolCallId,
-                timestamp: Date.now()
-              });
-              break;
-            }
-            case "tool-result": {
-              logger2.toolResult(chunk.toolName, JSON.stringify(chunk.output));
-              events.emit({
-                type: export_EventType.TOOL_CALL_RESULT,
-                messageId: v4_default(),
-                toolCallId: chunk.toolCallId,
-                content: typeof chunk.output === "string" ? chunk.output : JSON.stringify(chunk.output),
-                role: "tool",
-                timestamp: Date.now()
-              });
-              break;
-            }
-            case "finish-step": {
-              events.emit({
-                type: export_EventType.STEP_FINISHED,
-                stepName: `step-${currentStepNumber - 1}`,
-                timestamp: Date.now()
-              });
-              break;
-            }
-            case "error": {
-              throw chunk.error;
-            }
-          }
+        return;
+      }
+      case "text-delta": {
+        ctx.hasAnyContent = true;
+        if (!stepCtx.hasEmittedTextStart) {
+          stepCtx.messageId = v4_default();
+          events.emit({
+            type: export_EventType.TEXT_MESSAGE_START,
+            messageId: stepCtx.messageId,
+            role: "assistant",
+            timestamp: Date.now()
+          });
+          stepCtx.hasEmittedTextStart = true;
         }
-        if (session.abortController?.signal.aborted) {
-          span.endWithError("Run aborted by user");
+        events.emit({
+          type: export_EventType.TEXT_MESSAGE_CONTENT,
+          messageId: stepCtx.messageId,
+          delta: chunk.text,
+          timestamp: Date.now()
+        });
+        ctx.finalText += chunk.text;
+        return;
+      }
+      case "reasoning-delta": {
+        logger2.debug("Reasoning", { text: chunk.text });
+        return;
+      }
+      case "tool-input-start": {
+        ctx.hasAnyContent = true;
+        stepCtx.stepHadToolCalls = true;
+        if (stepCtx.messageId) {
           events.emit({
-            type: export_EventType.RUN_ERROR,
-            message: "Run aborted by user",
+            type: export_EventType.TEXT_MESSAGE_END,
+            messageId: stepCtx.messageId,
             timestamp: Date.now()
           });
-          return { success: false, error: "Run aborted", conversationHistory: messages };
         }
-        response = await stream.response;
-        const stepMessages = this.sanitizeMessages(response.messages);
-        allResponseMessages.push(...stepMessages);
-        if (!stepHadToolCalls) {
-          logger2.debug("Step had no tool calls, finishing run", { stepIteration });
-          break;
+        const toolDef = stepCtx.currentTools.find((t) => t.name === chunk.toolName);
+        const annotations = getToolAnnotations(toolDef);
+        const parentId = stepCtx.messageId ?? v4_default();
+        stepCtx.messageId = null;
+        const toolCallStartEvent = {
+          type: export_EventType.TOOL_CALL_START,
+          toolCallId: chunk.id,
+          toolCallName: chunk.toolName,
+          parentMessageId: parentId,
+          timestamp: Date.now()
+        };
+        if (annotations) {
+          toolCallStartEvent.annotations = annotations;
         }
-        currentMessages = [
-          ...currentMessages,
-          ...stepMessages
-        ];
-        logger2.debug("Continuing to next step after tool calls", {
-          stepIteration,
-          newMessageCount: currentMessages.length,
-          updatedToolCount: session.tools.length
-        });
+        events.emit(toolCallStartEvent);
+        stepCtx.activeToolCalls.set(chunk.id, { name: chunk.toolName, args: "" });
+        return;
       }
-      if (hasEmittedTextStart && messageId) {
+      case "tool-input-delta": {
+        const toolCall = stepCtx.activeToolCalls.get(chunk.id);
+        if (toolCall) {
+          toolCall.args += chunk.delta;
+          events.emit({
+            type: export_EventType.TOOL_CALL_ARGS,
+            toolCallId: chunk.id,
+            delta: chunk.delta,
+            timestamp: Date.now()
+          });
+        }
+        return;
+      }
+      case "tool-call": {
+        stepCtx.stepHadToolCalls = true;
+        stepCtx.completedToolCalls.add(chunk.toolCallId);
+        const toolCall = stepCtx.activeToolCalls.get(chunk.toolCallId);
+        const finalArgs = JSON.stringify(chunk.input);
+        if (toolCall && toolCall.args.length === 0) {
+          events.emit({
+            type: export_EventType.TOOL_CALL_ARGS,
+            toolCallId: chunk.toolCallId,
+            delta: finalArgs,
+            timestamp: Date.now()
+          });
+          toolCall.args = finalArgs;
+        }
         events.emit({
-          type: export_EventType.TEXT_MESSAGE_END,
-          messageId,
+          type: export_EventType.TOOL_CALL_END,
+          toolCallId: chunk.toolCallId,
           timestamp: Date.now()
         });
+        return;
       }
-      if (!hasAnyContent) {
-        span.endWithError("Empty response from AI");
+      case "tool-result": {
+        logger2.toolResult(chunk.toolName, JSON.stringify(chunk.output));
         events.emit({
-          type: export_EventType.RUN_ERROR,
-          message: "AI returned an empty response. This may be due to an ambiguous request. Please try being more specific.",
+          type: export_EventType.TOOL_CALL_RESULT,
+          messageId: v4_default(),
+          toolCallId: chunk.toolCallId,
+          content: typeof chunk.output === "string" ? chunk.output : JSON.stringify(chunk.output),
+          role: "tool",
           timestamp: Date.now()
         });
-        return {
-          success: false,
-          error: "Empty response from AI",
-          conversationHistory: messages
-        };
-      }
-      if (!response) {
-        throw new Error("No response from AI SDK");
+        return;
       }
-      if (finalText) {
-        logger2.aiResponse([finalText]);
+      case "finish": {
+        stepCtx.stepFinishReason = chunk.finishReason;
+        return;
       }
-      span.setOutput(finalText);
-      const traceId = span.popTraceId();
-      span.end();
-      events.emit({
-        type: export_EventType.RUN_FINISHED,
-        threadId: session.threadId,
-        runId: traceId || runId,
-        result: finalText,
-        timestamp: Date.now()
-      });
-      return {
-        success: true,
-        conversationHistory: [...messages, ...allResponseMessages]
-      };
-    } catch (error40) {
-      span.endWithError(error40 instanceof Error ? error40.message : String(error40));
-      logger2.error("Error calling AI SDK model", {
-        error: error40 instanceof Error ? error40.message : "Unknown error",
-        clientId: session.clientId
-      });
-      let errorCode = ErrorCode.UNKNOWN_ERROR;
-      let errorMessage = error40 instanceof Error ? error40.message : "Unknown error";
-      const isAPIError = (err) => {
-        return typeof err === "object" && err !== null;
-      };
-      if (isAPIError(error40)) {
-        const isOverloaded = error40.statusCode === 529 || error40.data?.error?.type === "overloaded_error" || error40.message && error40.message.toLowerCase().includes("overload");
-        if (isOverloaded) {
-          errorCode = ErrorCode.API_OVERLOADED;
-        }
-        const isRateLimited = error40.statusCode === 429;
-        if (isRateLimited) {
-          errorCode = ErrorCode.RATE_LIMITED;
+      case "finish-step": {
+        if (stepCtx.messageId) {
+          events.emit({
+            type: export_EventType.TEXT_MESSAGE_END,
+            messageId: stepCtx.messageId,
+            timestamp: Date.now()
+          });
+          stepCtx.messageId = null;
         }
+        events.emit({
+          type: export_EventType.STEP_FINISHED,
+          stepName: `step-${ctx.currentStepNumber - 1}`,
+          timestamp: Date.now()
+        });
+        return;
       }
-      if (!streamTextStarted) {
-        const telemetryMetadata = originalInput.forwardedProps?.telemetryMetadata;
-        span.recordError({
-          runId,
-          errorCategory: "pre_stream_error",
-          errorMessage,
-          sessionId: session.clientId,
-          threadId: session.threadId,
-          ipAddress: session.ipAddress,
-          metadata: { errorCode, toolCount: tools.length, messageCount: messages.length, ...telemetryMetadata }
+      case "tool-error": {
+        const errorContent = chunk.error instanceof Error ? chunk.error.message : String(chunk.error);
+        logger2.toolResult(chunk.toolName, `ERROR: ${errorContent}`);
+        events.emit({
+          type: export_EventType.TOOL_CALL_RESULT,
+          messageId: v4_default(),
+          toolCallId: chunk.toolCallId,
+          content: JSON.stringify({ error: errorContent }),
+          role: "tool",
+          timestamp: Date.now()
         });
+        return;
+      }
+      case "error": {
+        throw chunk.error;
       }
+    }
+  }
+  finalizeRun(ctx, events, span) {
+    if (!ctx.hasAnyContent) {
+      span.endWithError("Empty response from AI");
       events.emit({
         type: export_EventType.RUN_ERROR,
-        message: errorCode,
+        message: "AI returned an empty response. This may be due to an ambiguous request. Please try being more specific.",
         timestamp: Date.now()
       });
       return {
         success: false,
-        error: errorMessage,
-        conversationHistory: messages
+        error: "Empty response from AI",
+        conversationHistory: ctx.messages
       };
     }
+    if (!ctx.response) {
+      throw new Error("No response from AI SDK");
+    }
+    if (ctx.finalText) {
+      logger2.aiResponse([ctx.finalText]);
+    }
+    span.setOutput(ctx.finalText);
+    const traceId = span.popTraceId();
+    span.end();
+    events.emit({
+      type: export_EventType.RUN_FINISHED,
+      threadId: ctx.session.threadId,
+      runId: traceId || ctx.runId,
+      result: ctx.finalText,
+      timestamp: Date.now()
+    });
+    return {
+      success: true,
+      conversationHistory: [...ctx.messages, ...ctx.allResponseMessages]
+    };
+  }
+  handleRunError(error40, ctx, events, span) {
+    if (error40 instanceof AbortError) {
+      return { success: false, error: "Run aborted", conversationHistory: ctx.messages };
+    }
+    span.endWithError(error40 instanceof Error ? error40.message : String(error40));
+    logger2.error("Error calling AI SDK model", {
+      error: error40 instanceof Error ? error40.message : "Unknown error",
+      clientId: ctx.session.clientId
+    });
+    const { errorCode, errorMessage } = classifyApiError(error40);
+    if (!ctx.streamTextStarted) {
+      const telemetryMetadata = ctx.originalInput.forwardedProps?.telemetryMetadata;
+      span.recordError({
+        runId: ctx.runId,
+        errorCategory: "pre_stream_error",
+        errorMessage,
+        sessionId: ctx.session.clientId,
+        threadId: ctx.session.threadId,
+        ipAddress: ctx.session.ipAddress,
+        metadata: { errorCode, toolCount: ctx.tools.length, messageCount: ctx.messages.length, ...telemetryMetadata }
+      });
+    }
+    events.emit({
+      type: export_EventType.RUN_ERROR,
+      message: errorCode,
+      timestamp: Date.now()
+    });
+    return {
+      success: false,
+      error: errorMessage,
+      conversationHistory: ctx.messages
+    };
   }
   async resolveSystemPrompt() {
     if (!this.systemPrompt) {
@@ -114490,6 +114585,13 @@ class AISDKAgent {
 ${JSON.stringify(state, null, 2)}`
     };
   }
+  applyGracefulSummaryOverrides(isGracefulSummaryStep, stepConfig) {
+    if (!isGracefulSummaryStep)
+      return;
+    stepConfig.messages.push({ role: "user", content: "max steps reached, summarize progress" });
+    stepConfig.tools = undefined;
+    Object.assign(stepConfig.metadata, { toolCount: 0, gracefulSummary: true });
+  }
   filterTools(tools) {
     if (!this.toolFilter) {
       return tools;
@@ -114632,6 +114734,35 @@ ${val.text}`
     }
   }
 }
+function buildRecoveryToolResults(incompleteToolCalls, stepFinishReason, maxOutputTokens) {
+  if (incompleteToolCalls.length === 0 || stepFinishReason !== "length") {
+    return [];
+  }
+  const recoveryAssistantMessage = {
+    role: "assistant",
+    content: incompleteToolCalls.map((toolCall) => ({
+      type: "tool-call",
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      input: {}
+    }))
+  };
+  const recoveryToolResults = incompleteToolCalls.map((toolCall) => ({
+    role: "tool",
+    content: [
+      {
+        type: "tool-result",
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        output: {
+          type: "text",
+          value: `Error: Tool call "${toolCall.name}" failed because its arguments were cut off mid-stream by the output token limit (maxOutputTokens: ${maxOutputTokens}). This call was recorded with args={} as a placeholder — retry with shorter arguments. Truncated args (first 200 chars): ${toolCall.args.substring(0, 200)}`
+        }
+      }
+    ]
+  }));
+  return [recoveryAssistantMessage, ...recoveryToolResults];
+}
 // ../../node_modules/.bun/zod-to-json-schema@3.25.1+27912429049419a2/node_modules/zod-to-json-schema/dist/esm/Options.js
 var ignoreOverride2 = Symbol("Let zodToJsonSchema decide on which parser to use");
 var defaultOptions2 = {