@juspay/neurolink 12.14.7 → 12.14.9

package/dist/providers/googleVertex/client.js

@@ -977,9 +977,13 @@ export class GoogleVertexProvider extends BaseProvider {
     async createVertexGenAIClient(regionOverride) {
         warnGoogleSdkIgnoresProxy("GoogleVertex");
         const expressApiKey = this.resolveExpressApiKey();
-        // Resolved only on the ADC path: getVertexProjectId() throws when no
-        // project is configured, which an Express request legitimately has none of.
-        const project = expressApiKey ? "" : getVertexProjectId();
+        // Resolved only on the ADC path, and from the per-instance projectId the
+        // constructor already settled (credentials.projectId if supplied, else
+        // the same ambient getVertexProjectId() fallback) — not re-read from
+        // ambient env here, or a per-request projectId override would be built
+        // into the client with the wrong project while call sites elsewhere
+        // (generateContent's `project:` param) correctly used this.projectId.
+        const project = expressApiKey ? "" : this.projectId;
         const location = regionOverride || this.location || getVertexLocation();
         const mod = await import("@google/genai");
         const ctor = mod.GoogleGenAI;
@@ -1060,94 +1064,6 @@ export class GoogleVertexProvider extends BaseProvider {
         ].some((name) => (process.env[name] ?? "").trim().length > 0);
         return projectConfigured ? undefined : fromEnv;
     }
-    /**
-     * Convert one AI-SDK tool into a Vertex Gemini function declaration.
-     * Single source for the pre-loop snapshot AND the mid-turn discovery
-     * refresh, so tools hydrated by search_tools get the exact same schema
-     * treatment (inline, typed, additionalProperties stripped).
-     */
-    buildGeminiFunctionDeclaration(name, tool) {
-        const decl = {
-            name,
-            description: tool.description || `Tool: ${name}`,
-        };
-        // Access legacy `parameters` (AI SDK v3/v4) or current `inputSchema` (v6)
-        const legacyTool = tool;
-        const toolParams = legacyTool.parameters || tool.inputSchema;
-        if (toolParams) {
-            // Convert and inline schema to resolve $ref/definitions
-            const rawSchema = convertZodToJsonSchema(toolParams, "openApi3");
-            const inlinedSchema = inlineJsonSchema(rawSchema);
-            // Remove $schema if present - @google/genai doesn't need it
-            if (inlinedSchema.$schema) {
-                delete inlinedSchema.$schema;
-            }
-            // CRITICAL: Google Vertex AI requires ALL nested schemas to have a type field
-            // ensureNestedSchemaTypes recursively adds missing type fields to tool schemas
-            // Note: convertZodToJsonSchema now uses openApi3 target which produces nullable: true
-            const typedSchema = ensureNestedSchemaTypes(inlinedSchema);
-            // Strip `additionalProperties` recursively — Vertex Gemini's
-            // function-call validator rejects it on object schemas (returns
-            // 400 INVALID_ARGUMENT) even though it's valid OpenAPI 3. The
-            // field has no semantic meaning to the model, so dropping it
-            // before send is safe for every caller.
-            stripAdditionalPropertiesDeep(typedSchema);
-            decl.parametersJsonSchema = typedSchema;
-        }
-        return decl;
-    }
-    /**
-     * Mid-turn tool sync for the native Gemini loops. `search_tools` hydrates
-     * discovered tools into the live `options.tools` record between steps, but
-     * the loop's declarations + executeMap are a pre-loop snapshot — without
-     * this refresh, a tool discovered this turn stays invisible to the rest of
-     * the turn and every call to it dies as TOOL_NOT_FOUND. Mutates the
-     * declaration array in place (the request config holds it by reference)
-     * and clears breaker strikes accrued while the tool was still deferred.
-     */
-    refreshGeminiToolDeclarations(liveTools, declarations, executeMap, failedTools) {
-        if (!liveTools || !declarations) {
-            return;
-        }
-        const declared = new Set(declarations.map((d) => d.name));
-        for (const [name, tool] of Object.entries(liveTools)) {
-            if (declared.has(name)) {
-                continue;
-            }
-            declarations.push(this.buildGeminiFunctionDeclaration(name, tool));
-            if (tool.execute) {
-                executeMap.set(name, tool.execute);
-            }
-            failedTools.delete(name);
-            logger.info(`[GoogleVertex] Tool "${name}" hydrated mid-turn via discovery — added to Gemini declarations.`);
-        }
-    }
-    /**
-     * Dispatch-miss recovery for the native Gemini loops: the model called a
-     * name missing from the executeMap snapshot. Re-read the live record (a
-     * tool hydrated by search_tools in this very step batch) or auto-hydrate a
-     * deferred catalog tool the model called directly by its advertised name.
-     * Returns the dedup-wrapped executor, or undefined when the name is
-     * genuinely unknown — callers keep TOOL_NOT_FOUND for that case.
-     */
-    resolveGeminiToolOnMiss(name, liveTools, declarations, executeMap, failedTools) {
-        if (!declarations) {
-            return undefined;
-        }
-        const tool = resolveLiveTool(liveTools, name);
-        if (!tool?.execute) {
-            return undefined;
-        }
-        if (!declarations.some((d) => d.name === name)) {
-            declarations.push(this.buildGeminiFunctionDeclaration(name, tool));
-        }
-        executeMap.set(name, tool.execute);
-        // NOT_FOUND strikes accrued while the tool was deferred are snapshot
-        // artifacts, not real failures — reset so the breaker starts clean.
-        failedTools.delete(name);
-        logger.info(`[GoogleVertex] Tool "${name}" resolved mid-turn via discovery — executing.`);
-        return executeMap.get(name);
-    }
     /**
      * Convert one AI-SDK tool into an Anthropic (Claude-on-Vertex) tool
      * declaration. Single source for the pre-loop snapshot AND the mid-turn
@@ -1179,8 +1095,7 @@ export class GoogleVertexProvider extends BaseProvider {
         return anthropicTool;
     }
     /**
-     * Mid-turn tool sync for the Claude-on-Vertex loops — the Anthropic
-     * counterpart of refreshGeminiToolDeclarations. Claude only calls tools
+     * Mid-turn tool sync for the Claude-on-Vertex loops. Claude only calls tools
      * present in the request's `tools` array, so without this per-step refresh
      * a tool discovered via search_tools is unreachable for the rest of the
      * turn. Mutates the array in place (requestParams holds it by reference).
@@ -1203,8 +1118,7 @@ export class GoogleVertexProvider extends BaseProvider {
         }
     }
     /**
-     * Dispatch-miss recovery for the Claude-on-Vertex loops — the Anthropic
-     * counterpart of resolveGeminiToolOnMiss.
+     * Dispatch-miss recovery for the Claude-on-Vertex loops.
      */
     resolveAnthropicToolOnMiss(name, liveTools, declarations, executeMap, failedTools) {
         if (!declarations) {
@@ -1222,6 +1136,31 @@ export class GoogleVertexProvider extends BaseProvider {
         logger.info(`[GoogleVertex] Tool "${name}" resolved mid-turn via discovery — executing.`);
         return executeMap.get(name);
     }
+    /**
+     * Build the synthetic `final_result` tool used to force structured output
+     * on Claude-on-Vertex. Anthropic has no native responseSchema, so a schema
+     * is instead enforced by requiring the model to call this tool with
+     * matching arguments. Single source for the non-streaming and streaming
+     * paths — both previously built this object independently from their own
+     * schema variable, byte-identical apart from that variable's name.
+     */
+    buildFinalResultTool(schema) {
+        const schemaAsJson = convertZodToJsonSchema(schema);
+        const inlinedSchema = inlineJsonSchema(schemaAsJson);
+        if (inlinedSchema.$schema) {
+            delete inlinedSchema.$schema;
+        }
+        const typedSchema = ensureNestedSchemaTypes(inlinedSchema);
+        return {
+            name: "final_result",
+            description: "Return the final structured result. You MUST call this tool when you have gathered all information and are ready to provide the final answer. The arguments should contain the structured data matching the expected schema.",
+            input_schema: {
+                type: "object",
+                properties: typedSchema.properties || typedSchema,
+                required: typedSchema.required || [],
+            },
+        };
+    }
     /**
      * Execute stream using native @google/genai SDK for Gemini 3 models on Vertex AI
      * This bypasses @ai-sdk/google-vertex to properly handle thought_signature
@@ -3132,23 +3071,8 @@ export class GoogleVertexProvider extends BaseProvider {
         let schemaSystemPromptSuffix = "";
         if (streamOptions.schema) {
             useFinalResultTool = true;
-            // Convert schema to JSON schema format
-            const schemaAsJson = convertZodToJsonSchema(streamOptions.schema);
-            const inlinedSchema = inlineJsonSchema(schemaAsJson);
-            if (inlinedSchema.$schema) {
-                delete inlinedSchema.$schema;
-            }
-            const typedSchema = ensureNestedSchemaTypes(inlinedSchema);
             // Create final_result tool
-            const finalResultTool = {
-                name: "final_result",
-                description: "Return the final structured result. You MUST call this tool when you have gathered all information and are ready to provide the final answer. The arguments should contain the structured data matching the expected schema.",
-                input_schema: {
-                    type: "object",
-                    properties: typedSchema.properties || typedSchema,
-                    required: typedSchema.required || [],
-                },
-            };
+            const finalResultTool = this.buildFinalResultTool(streamOptions.schema);
             // Add to tools array or create new array
             if (!tools) {
                 tools = [];
@@ -3158,7 +3082,7 @@ export class GoogleVertexProvider extends BaseProvider {
             schemaSystemPromptSuffix =
                 "\n\nIMPORTANT: You MUST call the 'final_result' tool to return your response in the required structured format. Do not respond with plain text - always use the final_result tool.";
             logger.debug("[GoogleVertex] Added final_result tool for Anthropic structured output (stream)", {
-                schemaKeys: Object.keys(typedSchema),
+                schemaKeys: Object.keys(finalResultTool.input_schema.properties ?? {}),
                 totalTools: tools.length,
             });
         }
@@ -3719,10 +3643,19 @@ export class GoogleVertexProvider extends BaseProvider {
                     // with text in step 2 would look unfinished and fall into terminal
                     // handling. The finish reason is the per-turn signal — the engine
                     // reports "tool-calls" only when the cap was hit with tools still
-                    // pending.
+                    // pending. That signal is not enough on its own, though: Anthropic
+                    // reports stop_reason "tool_use" — which maps to finishReason
+                    // "tool-calls" — for ANY tool_use block, including a genuine
+                    // terminal `final_result` call. Without the third clause, a turn
+                    // that called a real tool earlier (toolCalls.length > 0) and then
+                    // legitimately finished via final_result reads as unfinished and
+                    // falls into the terminal-handling block below, which forces a
+                    // redundant second final_result call and pushes its JSON onto the
+                    // stream a second time.
                     modelFinished =
                         engineResult.toolCalls.length === 0 ||
-                            engineResult.finishReason !== "tool-calls";
+                            engineResult.finishReason !== "tool-calls" ||
+                            (useFinalResultTool && structuredOutputRef.value !== undefined);
                     // Replace in place: the terminal block and the finalization call both
                     // read `currentMessages`.
                     currentMessages.length = 0;
@@ -4361,23 +4294,8 @@ export class GoogleVertexProvider extends BaseProvider {
         let schemaSystemPromptSuffix = "";
         if (options.schema) {
             useFinalResultTool = true;
-            // Convert schema to JSON schema format
-            const schemaAsJson = convertZodToJsonSchema(options.schema);
-            const inlinedSchema = inlineJsonSchema(schemaAsJson);
-            if (inlinedSchema.$schema) {
-                delete inlinedSchema.$schema;
-            }
-            const typedSchema = ensureNestedSchemaTypes(inlinedSchema);
             // Create final_result tool
-            const finalResultTool = {
-                name: "final_result",
-                description: "Return the final structured result. You MUST call this tool when you have gathered all information and are ready to provide the final answer. The arguments should contain the structured data matching the expected schema.",
-                input_schema: {
-                    type: "object",
-                    properties: typedSchema.properties || typedSchema,
-                    required: typedSchema.required || [],
-                },
-            };
+            const finalResultTool = this.buildFinalResultTool(options.schema);
             // Add to tools array or create new array
             if (!tools) {
                 tools = [];
@@ -4387,7 +4305,7 @@ export class GoogleVertexProvider extends BaseProvider {
             schemaSystemPromptSuffix =
                 "\n\nIMPORTANT: You MUST call the 'final_result' tool to return your response in the required structured format. Do not respond with plain text - always use the final_result tool.";
             logger.debug("[GoogleVertex] Added final_result tool for Anthropic structured output (generate)", {
-                schemaKeys: Object.keys(typedSchema),
+                schemaKeys: Object.keys(finalResultTool.input_schema.properties ?? {}),
                 totalTools: tools.length,
             });
         }

package/dist/providers/huggingFace/client.js

@@ -97,6 +97,6 @@ export class HuggingFaceProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "huggingface", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
 }

package/dist/providers/llamaCpp.js

@@ -74,6 +74,6 @@ export class LlamaCppProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "llamacpp", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
 }

package/dist/providers/lmStudio.js

@@ -69,7 +69,7 @@ export class LMStudioProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "lm-studio", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     async validateConfiguration() {
         return this.probeModelsEndpoint(this.config.apiKey && this.config.apiKey !== LM_STUDIO_PLACEHOLDER_KEY

package/dist/providers/nvidiaNim/client.js

@@ -281,7 +281,7 @@ export class NvidiaNimProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "nvidia-nim", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     async validateConfiguration() {
         return (typeof this.config.apiKey === "string" &&

package/dist/providers/ollama/client.js

@@ -136,7 +136,7 @@ export class OllamaProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "ollama", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     // ===========================================================================
     // Optional hooks — Ollama-specific behaviour

package/dist/providers/openRouter/client.js

@@ -149,7 +149,7 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "openrouter", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     // ===========================================================================
     // Optional hooks — provider-specific quirks

package/dist/providers/openaiCompatible/client.js

@@ -85,6 +85,6 @@ export class OpenAICompatibleProvider extends OpenAIChatCompletionsProvider {
             },
             ...DEFAULT_ERROR_RULES,
         ];
-        return classifyProviderError(error, rules, "openai-compatible", this.modelName);
+        return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
 }

package/dist/proxy/bodyCaptureProcessing.js

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { mkdir, chmod, writeFile } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { promisify } from "node:util";
+import { sanitizeForLog } from "../utils/logSanitize.js";
 import { gzip as gzipCallback } from "node:zlib";
 const REQUEST_LOG_IO_TIMEOUT_MS = 5_000;
 /** Maximum redacted body bytes persisted per capture entry. */
@@ -43,6 +44,15 @@ function redactHeaders(headers) {
     return redacted;
 }
 const SENSITIVE_BODY_KEY = /^(?:password|access_token|refresh_token|api_key|apiKey|secret|authorization|token|credential|x-api-key)$/i;
+/** Error messages may contain nested JSON encoded as a string. */
+function redactNestedValue(key, value) {
+    if (SENSITIVE_BODY_KEY.test(key)) {
+        return "[REDACTED]";
+    }
+    return typeof value === "string"
+        ? sanitizeForLog(value.replace(SENSITIVE_BODY_KEYS, '$1"[REDACTED]"'), value.length)
+        : value;
+}
 /** Redact every value under a sensitive key, including objects and arrays. */
 function redactBody(body) {
     if (body === undefined || body === null) {
@@ -54,11 +64,44 @@ function redactBody(body) {
             value = JSON.parse(body);
         }
         catch {
-            // Non-JSON bodies (including SSE transcripts) keep the legacy fallback.
-            return body.replace(SENSITIVE_BODY_KEYS, '$1"[REDACTED]"');
+            if (/^(?:event|data):/m.test(body)) {
+                // Redact whole SSE data values, including nested credentials. Never
+                // retain a truncated/invalid JSON tail whose secret cannot be parsed.
+                return body
+                    .split(/\r\n\r\n|\n\n|\r\r/)
+                    .map((frame) => {
+                    const lines = frame.split(/\r\n|\n|\r/);
+                    const data = lines
+                        .filter((line) => line.startsWith("data:"))
+                        .map((line) => line.slice(5).trimStart())
+                        .join("\n");
+                    if (!data || data === "[DONE]") {
+                        return frame;
+                    }
+                    let redacted;
+                    try {
+                        redacted = JSON.stringify(JSON.parse(data), redactNestedValue);
+                    }
+                    catch {
+                        redacted = "[UNPARSEABLE DATA REDACTED]";
+                    }
+                    return [
+                        ...lines.filter((line) => !line.startsWith("data:")),
+                        `data: ${redacted}`,
+                    ].join("\n");
+                })
+                    .join("\n\n");
+            }
+            // Invalid or truncated structured JSON must not expose an unterminated
+            // credential value that a quoted-string regex cannot safely redact.
+            if (/^\s*[[{]/.test(body)) {
+                return "[UNPARSEABLE DATA REDACTED]";
+            }
+            // Plain-text bodies retain the existing credential-field redaction.
+            return sanitizeForLog(body.replace(SENSITIVE_BODY_KEYS, '$1"[REDACTED]"'), body.length);
         }
     }
-    return JSON.stringify(value, (key, nested) => SENSITIVE_BODY_KEY.test(key) ? "[REDACTED]" : nested);
+    return JSON.stringify(value, redactNestedValue);
 }
 /**
  * Restrict request and phase identifiers to characters safe for artifact
@@ -208,6 +251,7 @@ export async function processProxyBodyCapture(entry, logDir) {
     const headers = redactHeaders(entry.headers);
     const limit = logDir === null ? MAX_OTEL_CAPTURED_BODY_BYTES : MAX_CAPTURED_BODY_BYTES;
     const prepared = prepareRedactedBody(entry.body, limit);
+    prepared.truncated ||= entry.sourceTruncated === true;
     if (logDir === null) {
         return {
             headers,

package/dist/proxy/bodyCaptureWorker.js

@@ -1,5 +1,5 @@
 import { Worker } from "node:worker_threads";
-const MAX_PENDING = 16;
+const MAX_PENDING = 64;
 const MAX_PENDING_BYTES = 32 * 1024 * 1024;
 // Bound retained UTF-16 strings rather than a 3x UTF-8 guess. This accommodates
 // the observed 7.3 MB JSON requests while retaining a 32 MiB aggregate pool.
@@ -29,7 +29,7 @@ const pending = new Map();
  * Conservatively bound clone size and traversal work without invoking
  * getters or serializers.
  */
-function estimateCloneBytes(value) {
+function estimateCloneBytes(value, maxEntryBytes) {
     const stack = [value];
     const seen = new Set();
     let bytes = 0, nodes = 0;
@@ -37,8 +37,8 @@ function estimateCloneBytes(value) {
         if (++nodes > 100_000) {
             throw new Error("body_capture_traversal_limit");
         }
-        if (bytes > MAX_ENTRY_BYTES) {
-            throw new Error("body_capture_entry_too_large");
+        if (bytes > maxEntryBytes) {
+            return bytes;
         }
         const item = stack.pop();
         if (typeof item === "string") {
@@ -68,8 +68,8 @@ function estimateCloneBytes(value) {
             if (stack.length > 100_000) {
                 throw new Error("body_capture_traversal_limit");
             }
-            if (bytes > MAX_ENTRY_BYTES) {
-                throw new Error("body_capture_entry_too_large");
+            if (bytes > maxEntryBytes) {
+                return bytes;
             }
         }
     }
@@ -135,10 +135,13 @@ function getWorker() {
 /** Bounded bulk capture. Failures are indexed; never fall back to blocking work. */
 export async function captureProxyBody(entry, logDir, consume) {
     snapshot.attempted += 1;
+    // An OTel capture can use the existing byte pool when it is otherwise idle.
+    // Raising the slot count does not raise the aggregate retained-memory bound.
+    const maxEntryBytes = logDir === null ? MAX_PENDING_BYTES : MAX_ENTRY_BYTES;
     let bytes;
     let admissionError;
     try {
-        bytes = estimateCloneBytes(entry);
+        bytes = estimateCloneBytes(entry, maxEntryBytes);
     }
     catch (error) {
         bytes = Infinity;
@@ -152,12 +155,12 @@ export async function captureProxyBody(entry, logDir, consume) {
                 ? error.message
                 : "body_capture_unsupported_value";
     }
-    if (bytes > MAX_ENTRY_BYTES ||
+    if (bytes > maxEntryBytes ||
         snapshot.pending >= MAX_PENDING ||
         snapshot.pendingBytes + bytes > MAX_PENDING_BYTES ||
         Date.now() < retryAfter) {
         snapshot.rejected += 1;
-        const error = bytes > MAX_ENTRY_BYTES
+        const error = bytes > maxEntryBytes
             ? (admissionError ?? "body_capture_entry_too_large")
             : Date.now() < retryAfter
                 ? "body_worker_backoff"
@@ -170,7 +173,7 @@ export async function captureProxyBody(entry, logDir, consume) {
             error,
             stored: { bodyWriteFailed: true },
             admission: {
-                limitingResource: bytes > MAX_ENTRY_BYTES
+                limitingResource: bytes > maxEntryBytes
                     ? "entry"
                     : Date.now() < retryAfter
                         ? "worker"
@@ -178,6 +181,7 @@ export async function captureProxyBody(entry, logDir, consume) {
                             ? "captures"
                             : "bytes",
                 estimatedBytes: Number.isFinite(bytes) ? bytes : undefined,
+                maxEntryBytes,
                 pending: snapshot.pending,
                 pendingBytes: snapshot.pendingBytes,
                 maxPending: MAX_PENDING,

package/dist/proxy/claudeOutputObservation.d.ts

@@ -0,0 +1,9 @@
+import type { RequestLogEntry, SSETelemetry } from "../types/index.js";
+/** Content visible to the caller; thinking and empty text are not useful output. */
+export declare function hasUsefulClaudeContent(value: unknown): boolean;
+/** A complete JSON response becomes observable when its body has been read. */
+export declare function observeClaudeJsonOutput(metadata: Record<string, unknown>, value: unknown, at?: number): void;
+/** Keep unavailable observations distinct from a complete stream with no output. */
+export declare function observeClaudeStreamOutput(metadata: Record<string, unknown>, data: SSETelemetry): void;
+/** Final records always explain whether useful-output latency was observed. */
+export declare function claudeOutputLogFields(metadata: Record<string, unknown>, requestStartTime: number): Pick<RequestLogEntry, "firstUsefulOutputMs" | "firstUsefulOutputStatus" | "firstUsefulOutputEvent" | "firstUsefulOutputUnavailableReason">;

package/dist/proxy/claudeOutputObservation.js

@@ -0,0 +1,85 @@
+/** Content visible to the caller; thinking and empty text are not useful output. */
+export function hasUsefulClaudeContent(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const block = value;
+    if (Array.isArray(block.content)) {
+        return block.content.some(hasUsefulClaudeContent);
+    }
+    if (block.type === "thinking" || block.type === "redacted_thinking") {
+        return false;
+    }
+    if (typeof block.text === "string" && block.text.trim().length > 0) {
+        return true;
+    }
+    if (typeof block.refusal === "string" && block.refusal.trim().length > 0) {
+        return true;
+    }
+    return ((block.type === "tool_use" || block.type === "server_tool_use") &&
+        typeof block.name === "string" &&
+        block.name.length > 0 &&
+        block.input !== undefined);
+}
+/** A complete JSON response becomes observable when its body has been read. */
+export function observeClaudeJsonOutput(metadata, value, at = Date.now()) {
+    if (!value ||
+        typeof value !== "object" ||
+        !Array.isArray(value.content)) {
+        metadata.firstUsefulOutputStatus = "not_observed";
+        metadata.firstUsefulOutputUnavailableReason = "unrecognized_response";
+        return;
+    }
+    if (hasUsefulClaudeContent(value)) {
+        metadata.firstUsefulOutputAt = at;
+        metadata.firstUsefulOutputStatus = "observed";
+        metadata.firstUsefulOutputEvent = "json_response.content";
+    }
+    else {
+        metadata.firstUsefulOutputStatus = "no_useful_output";
+        delete metadata.firstUsefulOutputAt;
+        delete metadata.firstUsefulOutputEvent;
+    }
+    delete metadata.firstUsefulOutputUnavailableReason;
+}
+/** Keep unavailable observations distinct from a complete stream with no output. */
+export function observeClaudeStreamOutput(metadata, data) {
+    delete metadata.firstUsefulOutputAt;
+    delete metadata.firstUsefulOutputEvent;
+    delete metadata.firstUsefulOutputUnavailableReason;
+    if (!data.observationIncomplete && data.firstUsefulOutputAt !== undefined) {
+        metadata.firstUsefulOutputAt = data.firstUsefulOutputAt;
+        metadata.firstUsefulOutputEvent = data.firstUsefulOutputEvent;
+        metadata.firstUsefulOutputStatus = "observed";
+    }
+    else if (!data.observationIncomplete && data.messageStopReceived) {
+        metadata.firstUsefulOutputStatus = "no_useful_output";
+    }
+    else {
+        metadata.firstUsefulOutputStatus = "not_observed";
+        metadata.firstUsefulOutputUnavailableReason = data.observationIncomplete
+            ? "incomplete_observation"
+            : "stream_incomplete";
+    }
+}
+/** Final records always explain whether useful-output latency was observed. */
+export function claudeOutputLogFields(metadata, requestStartTime) {
+    const at = metadata.firstUsefulOutputAt;
+    if (typeof at === "number" && Number.isFinite(at)) {
+        return {
+            firstUsefulOutputMs: Math.max(0, at - requestStartTime),
+            firstUsefulOutputStatus: "observed",
+            firstUsefulOutputEvent: typeof metadata.firstUsefulOutputEvent === "string"
+                ? metadata.firstUsefulOutputEvent
+                : "translated_output",
+        };
+    }
+    return metadata.firstUsefulOutputStatus === "no_useful_output"
+        ? { firstUsefulOutputStatus: "no_useful_output" }
+        : {
+            firstUsefulOutputStatus: "not_observed",
+            firstUsefulOutputUnavailableReason: typeof metadata.firstUsefulOutputUnavailableReason === "string"
+                ? metadata.firstUsefulOutputUnavailableReason
+                : "response_not_observed",
+        };
+}

package/dist/proxy/codexUsage.js

@@ -53,20 +53,22 @@ function usefulOutputItem(item) {
         if (item.type === "function_call") {
             return ("arguments" in item &&
                 typeof item.arguments === "string" &&
-                item.arguments.length > 0);
+                item.arguments.trim().length > 0);
         }
         if (item.type === "custom_tool_call") {
             return ("input" in item &&
                 typeof item.input === "string" &&
-                item.input.length > 0);
+                item.input.trim().length > 0);
         }
         if (item.type === "output_text") {
-            return ("text" in item && typeof item.text === "string" && item.text.length > 0);
+            return ("text" in item &&
+                typeof item.text === "string" &&
+                item.text.trim().length > 0);
         }
         if (item.type === "refusal") {
             return ("refusal" in item &&
                 typeof item.refusal === "string" &&
-                item.refusal.length > 0);
+                item.refusal.trim().length > 0);
         }
     }
     return ("content" in item &&
@@ -213,7 +215,7 @@ export function createCodexUsageTap() {
                     type === "response.refusal.delta" ||
                     type === "response.function_call_arguments.delta") &&
                     typeof event.delta === "string" &&
-                    event.delta.length > 0) {
+                    event.delta.trim().length > 0) {
                     if (evidence.firstUsefulOutputAt === undefined) {
                         evidence.firstUsefulOutputAt = Date.now();
                         evidence.firstUsefulOutputEvent = String(type);
@@ -232,22 +234,22 @@ export function createCodexUsageTap() {
                     completedResponse.output.some(usefulOutputItem);
                 const usefulDone = (type === "response.output_text.done" &&
                     typeof event.text === "string" &&
-                    event.text.length > 0) ||
+                    event.text.trim().length > 0) ||
                     (type === "response.refusal.done" &&
                         typeof event.refusal === "string" &&
-                        event.refusal.length > 0) ||
+                        event.refusal.trim().length > 0) ||
                     (type === "response.function_call_arguments.done" &&
                         typeof event.arguments === "string" &&
-                        event.arguments.length > 0) ||
+                        event.arguments.trim().length > 0) ||
                     (type === "response.custom_tool_call_input.done" &&
                         typeof event.input === "string" &&
-                        event.input.length > 0) ||
+                        event.input.trim().length > 0) ||
                     ((type === "response.content_part.added" ||
                         type === "response.content_part.done") &&
                         usefulOutputItem(event.part));
                 const usefulToolDelta = type === "response.custom_tool_call_input.delta" &&
                     typeof event.delta === "string" &&
-                    event.delta.length > 0;
+                    event.delta.trim().length > 0;
                 if (evidence.firstUsefulOutputAt === undefined &&
                     (usefulDone ||
                         usefulCompletion ||

package/dist/proxy/otelLogSink.js

@@ -26,7 +26,7 @@ const bodyDelivery = {
     pendingBytes: 0,
     highWaterPending: 0,
     highWaterBytes: 0,
-    maxPending: 16,
+    maxPending: 64,
     maxPendingBytes: 32 * 1024 * 1024,
 };
 /** Explicit opt-in; configuration never silently falls back to file logging. */