@jaypie/llm 1.3.5 → 1.3.7

package/dist/cjs/index.cjs

@@ -101,7 +101,10 @@ const PROVIDER = {
     ANTHROPIC: {
         // https://docs.anthropic.com/en/docs/about-claude/models/overview
         MAX_TOKENS: {
-            DEFAULT: 4096,
+            // Non-streaming ceiling: responses above ~16K output tokens risk HTTP
+            // timeouts; streaming requests resolve to the model maximum instead
+            // (see util/maxOutputTokens.ts)
+            DEFAULT: 16384,
         },
         MODEL: {
             DEFAULT: FIRST_CLASS_PROVIDER.ANTHROPIC.DEFAULT,
@@ -450,14 +453,12 @@ class BaseProviderAdapter {
     /**
      * Default implementation returns false - override for providers with native structured output
      */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     hasStructuredOutput(_response) {
         return false;
     }
     /**
      * Default implementation returns undefined - override for providers with native structured output
      */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     extractStructuredOutput(_response) {
         return undefined;
     }
@@ -489,6 +490,18 @@ var LlmResponseStatus;
     LlmResponseStatus["Incomplete"] = "incomplete";
     LlmResponseStatus["InProgress"] = "in_progress";
 })(LlmResponseStatus || (LlmResponseStatus = {}));
+// Progress
+exports.LlmProgressEventType = void 0;
+(function (LlmProgressEventType) {
+    LlmProgressEventType["Done"] = "done";
+    LlmProgressEventType["ModelRequest"] = "model_request";
+    LlmProgressEventType["ModelResponse"] = "model_response";
+    LlmProgressEventType["Retry"] = "retry";
+    LlmProgressEventType["Start"] = "start";
+    LlmProgressEventType["ToolCall"] = "tool_call";
+    LlmProgressEventType["ToolError"] = "tool_error";
+    LlmProgressEventType["ToolResult"] = "tool_result";
+})(exports.LlmProgressEventType || (exports.LlmProgressEventType = {}));
 
 //
 //
@@ -925,6 +938,52 @@ function jsonSchemaToOpenApi3(schema) {
 
 const getLogger$6 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 
+//
+//
+// Constants
+//
+// Non-streaming requests above ~16K output tokens risk HTTP timeouts
+// (Anthropic guidance is to stream anything larger), so non-streaming
+// defaults are capped here and only streaming requests resolve to the
+// full model maximum.
+const NON_STREAMING_MAX_TOKENS = PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT;
+// Maximum output tokens by model; first match wins.
+// Providers without low output ceilings (OpenAI, xAI) are intentionally
+// absent — their requests leave the limit unset.
+const MODEL_MAX_OUTPUT_TOKENS = [
+    // Anthropic — https://platform.claude.com/docs/en/about-claude/models/overview
+    { pattern: /^claude-opus-4-(0$|1$|1-|2025)/, tokens: 32000 },
+    { pattern: /^claude-opus-4-5/, tokens: 64000 },
+    { pattern: /^claude-sonnet-4-(0$|5$|5-|2025)/, tokens: 64000 },
+    { pattern: /haiku/, tokens: 64000 },
+    { pattern: /claude|fable|mythos|opus|sonnet/, tokens: 128000 },
+    // Google — https://ai.google.dev/gemini-api/docs/models
+    { pattern: /gemini-(2\.5|3)/, tokens: 65536 },
+    { pattern: /gemini/, tokens: 8192 },
+];
+//
+//
+// Main
+//
+/**
+ * Maximum output tokens the model supports, or undefined when unknown.
+ */
+function maxOutputTokens(model) {
+    const match = MODEL_MAX_OUTPUT_TOKENS.find(({ pattern }) => pattern.test(model));
+    return match?.tokens;
+}
+/**
+ * Default output token limit for a request: the model maximum when
+ * streaming, capped at the non-streaming maximum otherwise. Returns
+ * undefined when the model's maximum is unknown.
+ */
+function resolveMaxOutputTokens(model, { stream = false } = {}) {
+    const max = maxOutputTokens(model);
+    if (max === undefined)
+        return undefined;
+    return stream ? max : Math.min(max, NON_STREAMING_MAX_TOKENS);
+}
+
 // Turn policy constants
 const MAX_TURNS_ABSOLUTE_LIMIT = 72;
 const MAX_TURNS_DEFAULT_LIMIT = 24;
@@ -1749,11 +1808,13 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 lastMsg.content = lastMsg.content + "\n\n" + request.instructions;
             }
         }
+        const model = (request.model ||
+            this.defaultModel);
         const anthropicRequest = {
-            model: (request.model ||
-                this.defaultModel),
+            model,
             messages,
-            max_tokens: PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
+            max_tokens: resolveMaxOutputTokens(model, { stream: request.stream }) ??
+                PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
             stream: false,
         };
         if (request.system) {
@@ -1816,7 +1877,6 @@ class AnthropicAdapter extends BaseProviderAdapter {
     // outputSchema is part of the interface contract but Anthropic now uses
     // native `output_format` (set in buildRequest), so we no longer inject a
     // synthetic structured-output tool here.
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _outputSchema) {
         return toolkit.tools.map((tool) => ({
             name: tool.name,
@@ -3003,6 +3063,18 @@ class GoogleAdapter extends BaseProviderAdapter {
                     : structuredOutputInstruction,
             };
         }
+        // Default output ceiling: Google's own default (8,192) silently
+        // truncates long generations, so resolve to the model maximum (capped
+        // for non-streaming); providerOptions below override
+        const maxOutputTokens = resolveMaxOutputTokens(geminiRequest.model, {
+            stream: request.stream,
+        });
+        if (maxOutputTokens !== undefined) {
+            geminiRequest.config = {
+                ...geminiRequest.config,
+                maxOutputTokens,
+            };
+        }
         // Add provider-specific options
         if (request.providerOptions) {
             geminiRequest.config = {
@@ -3024,7 +3096,6 @@ class GoogleAdapter extends BaseProviderAdapter {
     // structured output via `responseJsonSchema`/`responseSchema` (or the
     // legacy fake-tool injected in buildRequest as a fallback). We no longer
     // inject a synthetic structured-output tool here.
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _outputSchema) {
         return toolkit.tools.map((tool) => ({
             name: tool.name,
@@ -4689,7 +4760,6 @@ class OpenRouterAdapter extends BaseProviderAdapter {
     // native `response_format` (set in buildRequest), so we no longer inject a
     // synthetic structured-output tool here. The legacy fake-tool injection
     // happens in buildRequest only as a runtime fallback.
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _outputSchema) {
         return toolkit.tools.map((tool) => ({
             name: tool.name,
@@ -6075,6 +6145,25 @@ class InputProcessor {
 // Export singleton instance for convenience
 const inputProcessor = new InputProcessor();
 
+/**
+ * Deliver a progress event to the caller's onProgress callback.
+ * Errors thrown by the callback are logged and swallowed — progress
+ * reporting must never interrupt the operate loop.
+ */
+async function emitProgress({ event, onProgress, }) {
+    if (!onProgress) {
+        return;
+    }
+    try {
+        await onProgress(event);
+    }
+    catch (error) {
+        const log = getLogger$6();
+        log.warn(`[operate] onProgress callback threw on "${event.type}" event`);
+        log.var({ error });
+    }
+}
+
 //
 //
 // Main
@@ -6500,12 +6589,21 @@ class OperateLoop {
         const log = getLogger$6();
         // Log what was passed to operate
         log.trace("[operate] Starting operate loop");
-        log.var({ "operate.input": input });
-        log.var({ "operate.options": options });
+        log.trace.var({ "operate.input": input });
+        log.trace.var({ "operate.options": options });
         // Initialize state
         const state = await this.initializeState(input, options);
         const context = this.createContext(options);
         const modelName = options.model ?? this.adapter.defaultModel;
+        await emitProgress({
+            event: {
+                maxTurns: state.maxTurns,
+                model: modelName,
+                provider: this.adapter.name,
+                type: exports.LlmProgressEventType.Start,
+            },
+            onProgress: options.onProgress,
+        });
         // Enclosing LLM Observability span (no-op when DD_LLMOBS_ENABLED is unset).
         // Child llm/tool spans nest under it via the SDK's active-span context.
         return withLlmObsSpan({
@@ -6543,6 +6641,15 @@ class OperateLoop {
                 metrics: usageToLlmObsMetrics(response.usage),
                 outputData: response.content,
             });
+            await emitProgress({
+                event: {
+                    content: response.content,
+                    turn: state.currentTurn,
+                    type: exports.LlmProgressEventType.Done,
+                    usage: response.usage,
+                },
+                onProgress: options.onProgress,
+            });
             return response;
         });
     }
@@ -6637,18 +6744,54 @@ class OperateLoop {
         });
         // Build provider-specific request
         const providerRequest = this.adapter.buildRequest(request);
-        // Log what was passed to the model
+        // Log a draconian subset of the request; the full payload is available
+        // via the beforeEachModelRequest hook
         log.trace("[operate] Calling model");
-        log.var({ "operate.request": providerRequest });
+        log.trace.var({
+            "operate.request": {
+                latest: this.summarizeHistoryItem(request.messages[request.messages.length - 1]),
+                messages: request.messages.length,
+                model: request.model,
+                turn: state.currentTurn,
+            },
+        });
+        await emitProgress({
+            event: {
+                model: request.model,
+                turn: state.currentTurn,
+                type: exports.LlmProgressEventType.ModelRequest,
+            },
+            onProgress: options.onProgress,
+        });
         // Execute beforeEachModelRequest hook
         await this.hookRunnerInstance.runBeforeModelRequest(context.hooks, {
             input: state.currentInput,
             options,
             providerRequest,
         });
+        // Emit retry progress alongside the caller's onRetryableModelError hook
+        const hooks = context.hooks;
+        const hooksWithProgress = options.onProgress
+            ? {
+                ...hooks,
+                onRetryableModelError: async (retryContext) => {
+                    await emitProgress({
+                        event: {
+                            error: retryContext.error instanceof Error
+                                ? retryContext.error.message
+                                : String(retryContext.error),
+                            turn: state.currentTurn,
+                            type: exports.LlmProgressEventType.Retry,
+                        },
+                        onProgress: options.onProgress,
+                    });
+                    return hooks?.onRetryableModelError?.(retryContext);
+                },
+            }
+            : hooks;
         // Execute with retry inside a child llm span (no-op when llmobs disabled).
         // RetryExecutor handles error hooks and throws appropriate errors.
-        const { parsed, response } = await withLlmObsSpan({
+        const { parsed, response, toolCalls } = await withLlmObsSpan({
             kind: "llm",
             modelName: options.model ?? this.adapter.defaultModel,
             modelProvider: this.adapter.name,
@@ -6660,19 +6803,43 @@ class OperateLoop {
                     options,
                     providerRequest,
                 },
-                hooks: context.hooks,
+                hooks: hooksWithProgress,
             });
-            // Log what was returned from the model
-            log.trace("[operate] Model response received");
-            log.var({ "operate.response": response });
             // Parse response
             const parsed = this.adapter.parseResponse(response, options);
+            const toolCalls = parsed.hasToolCalls
+                ? this.adapter.extractToolCalls(response)
+                : [];
+            // Log only the text or tool calls; the full payload is available
+            // via the afterEachModelResponse hook
+            log.trace("[operate] Model response received");
+            log.trace.var({
+                "operate.response": toolCalls.length > 0
+                    ? toolCalls.map(({ arguments: args, name }) => ({
+                        arguments: args,
+                        name,
+                    }))
+                    : parsed.content,
+            });
             annotateLlmObs({
                 inputData: state.currentInput,
                 metrics: usageToLlmObsMetrics(parsed.usage ? [parsed.usage] : undefined),
                 outputData: parsed.content ?? "",
             });
-            return { parsed, response };
+            return { parsed, response, toolCalls };
+        });
+        await emitProgress({
+            event: {
+                content: parsed.content,
+                toolCalls: toolCalls.map(({ arguments: args, name }) => ({
+                    arguments: args,
+                    name,
+                })),
+                turn: state.currentTurn,
+                type: exports.LlmProgressEventType.ModelResponse,
+                usage: parsed.usage ? [parsed.usage] : undefined,
+            },
+            onProgress: options.onProgress,
         });
         // Track usage
         if (parsed.usage) {
@@ -6701,7 +6868,6 @@ class OperateLoop {
         }
         // Handle tool calls
         if (parsed.hasToolCalls) {
-            const toolCalls = this.adapter.extractToolCalls(response);
             if (toolCalls.length > 0 && state.toolkit && state.maxTurns > 1) {
                 // Track updated provider request for tool results
                 let currentProviderRequest = providerRequest;
@@ -6713,6 +6879,14 @@ class OperateLoop {
                 // Process each tool call
                 for (const toolCall of toolCalls) {
                     try {
+                        await emitProgress({
+                            event: {
+                                tool: { arguments: toolCall.arguments, name: toolCall.name },
+                                turn: state.currentTurn,
+                                type: exports.LlmProgressEventType.ToolCall,
+                            },
+                            onProgress: options.onProgress,
+                        });
                         // Execute beforeEachTool hook
                         await this.hookRunnerInstance.runBeforeTool(context.hooks, {
                             args: toolCall.arguments,
@@ -6732,6 +6906,14 @@ class OperateLoop {
                             });
                             return result;
                         });
+                        await emitProgress({
+                            event: {
+                                tool: { name: toolCall.name },
+                                turn: state.currentTurn,
+                                type: exports.LlmProgressEventType.ToolResult,
+                            },
+                            onProgress: options.onProgress,
+                        });
                         // Execute afterEachTool hook
                         await this.hookRunnerInstance.runAfterTool(context.hooks, {
                             args: toolCall.arguments,
@@ -6755,6 +6937,15 @@ class OperateLoop {
                         state.responseBuilder.appendToHistory(toolResultFormatted);
                     }
                     catch (error) {
+                        await emitProgress({
+                            event: {
+                                error: error.message,
+                                tool: { name: toolCall.name },
+                                turn: state.currentTurn,
+                                type: exports.LlmProgressEventType.ToolError,
+                            },
+                            onProgress: options.onProgress,
+                        });
                         // Execute onToolError hook
                         await this.hookRunnerInstance.runOnToolError(context.hooks, {
                             args: toolCall.arguments,
@@ -6828,6 +7019,20 @@ class OperateLoop {
         }
         return false; // Stop loop
     }
+    /**
+     * Draconian summary of a history item for trace logging: string message
+     * content is kept; everything else is reduced to its type.
+     */
+    summarizeHistoryItem(item) {
+        if (!item) {
+            return undefined;
+        }
+        const record = item;
+        if (typeof record.content === "string") {
+            return { content: record.content, role: record.role };
+        }
+        return { type: record.type ?? "message" };
+    }
     /**
      * Reconcile structured output against the declared `format` contract. A
      * declared `format` is a schema contract: returned keys should match the
@@ -7021,6 +7226,7 @@ class StreamLoop {
                     messages: state.currentInput,
                     model: options.model ?? this.adapter.defaultModel,
                     providerOptions: options.providerOptions,
+                    stream: true,
                     system: options.system,
                     temperature: options.temperature,
                     tools: state.formattedTools,
@@ -7089,6 +7295,7 @@ class StreamLoop {
             messages: state.currentInput,
             model: options.model ?? this.adapter.defaultModel,
             providerOptions: options.providerOptions,
+            stream: true,
             system: options.system,
             temperature: options.temperature,
             tools: state.formattedTools,