@xingjisoft/neutrino 0.6.2 → 0.7.0

package/dist/llm/client.js

@@ -1,4 +1,5 @@
 import { INTENSITY_PARAMS, intensityForModel, modelUsesReasoning } from "../config.js";
+import { DiagnosticRequest, diagnosticHash } from "./diagnostics.js";
 import { currentTask, TaskControlError } from "./runtime.js";
 import { inputTokenBound, DEFAULT_OUTPUT_TOKENS } from "./context.js";
 import { HttpStatusError, describeError, isRetriableFailure, retryDelayMs, retryPolicy, waitBeforeRetry, } from "./retry.js";
@@ -35,7 +36,7 @@ const SUMMARY_SYSTEM_PROMPT = "You compress the conversation history of an AI co
  * token already reached the user, and nesting two retry loops would multiply
  * both the request count and the total wait by the attempt budget.
  */
-async function postStream(url, init) {
+async function postStream(url, init, diagnostic) {
     const controller = new AbortController();
     const abort = () => controller.abort(init.signal?.reason);
     if (init.signal?.aborted)
@@ -44,7 +45,11 @@ async function postStream(url, init) {
         init.signal?.addEventListener("abort", abort, { once: true });
     const timer = setTimeout(() => controller.abort(new Error(`request timed out after ${CONNECT_TIMEOUT_MS / 1000}s`)), CONNECT_TIMEOUT_MS);
     try {
-        return await fetch(url, { ...init, signal: controller.signal });
+        if (diagnostic && typeof init.body === "string")
+            diagnostic.dispatch(init.body);
+        const response = await fetch(url, { ...init, signal: controller.signal });
+        diagnostic?.headers(response.status);
+        return response;
     }
     finally {
         clearTimeout(timer);
@@ -64,6 +69,7 @@ function resolvePolicy(options) {
  */
 async function pauseForRetry(attempt, policy, error, options) {
     const delayMs = retryDelayMs(attempt - 1, policy);
+    options.diagnosticObserver?.retry(delayMs);
     options.onRetry?.({ attempt: attempt + 1, attempts: policy.attempts, delayMs, reason: describeError(error) });
     return waitBeforeRetry(attempt - 1, policy, options.cancelled);
 }
@@ -111,7 +117,8 @@ export class LLMClient {
             { role: "user", content: transcript },
         ];
         let out = "";
-        for await (const chunk of this.streamTurn(messages, undefined, options))
+        const streamOptions = currentTask()?.runtime.diagnostics ? { ...options, diagnostic: { ...options.diagnostic, role: "compression" } } : options;
+        for await (const chunk of this.streamTurn(messages, undefined, streamOptions))
             out += chunk;
         const text = out.trim();
         if (this.outcome?.status === "failed" || !text || text.startsWith("[Error"))
@@ -141,6 +148,11 @@ export class LLMClient {
         this.anthropicContent = [];
         const controller = new AbortController();
         const runtime = currentTask()?.runtime;
+        const diagnostic = runtime?.diagnostics ? new DiagnosticRequest(runtime.diagnostics, { role: currentTask()?.depth ? "worker" : "main", ...options.diagnostic }, currentTask()) : undefined;
+        if (diagnostic)
+            runtime.diagnostics.emit("model_configuration", { request_id: diagnostic.requestId,
+                model_config_hash: diagnosticHash({ model: this.model.name, provider: this.provider, intensity: this.intensity, professional: this.professional, temperature: this.temperature, top_p: this.top_p }),
+                output_budget: options.maxOutputTokens ?? (runtime ? DEFAULT_OUTPUT_TOKENS : null) }, currentTask());
         const taskSignal = currentTask()?.signal;
         const release = runtime?.activity();
         const rootAbort = () => controller.abort(taskSignal?.reason);
@@ -157,10 +169,18 @@ export class LLMClient {
             if (options.cancelled?.())
                 controller.abort();
         }, 100) : null;
-        const requestOptions = { ...options, maxOutputTokens: options.maxOutputTokens ?? (runtime ? DEFAULT_OUTPUT_TOKENS : undefined), signal: controller.signal, cancelled };
+        const requestOptions = { ...options, ...(diagnostic ? { diagnosticObserver: diagnostic } : {}), maxOutputTokens: options.maxOutputTokens ?? (runtime ? DEFAULT_OUTPUT_TOKENS : undefined), signal: controller.signal, cancelled };
         try {
             if (controller.signal.aborted)
                 return;
+            if (tools && runtime?.plugins) {
+                tools = runtime.availableTools(tools);
+                const suffix = await runtime.plugins.requestSuffix({ provider: this.provider, model: this.model.name, role: currentTask()?.role ?? "main", toolCount: tools.length });
+                if (suffix) {
+                    messages = messages.map((message, index) => index === 0 && message.role === "system" ? { ...message, content: (message.content ?? "") + suffix } : message);
+                    runtime.note("plugin_request_suffix", { suffix });
+                }
+            }
             if (this.provider === "Anthropic") {
                 yield* this.streamAnthropic(messages, tools, requestOptions);
                 return;
@@ -179,6 +199,7 @@ export class LLMClient {
                 this.outcome = { status: "failed", error: { code: "output_limit", message: "Model output reached its limit before completion; no tool calls from this response were executed" } };
             }
             this.outcome ??= { status: cancelled() ? "cancelled" : "completed" };
+            diagnostic?.end(this.outcome.status);
             taskSignal?.removeEventListener("abort", rootAbort);
             release?.();
             if (timer)
@@ -275,7 +296,7 @@ export class LLMClient {
             headers,
             body: JSON.stringify(payload),
             signal: options.signal,
-        });
+        }, options.diagnosticObserver);
         if (!resp.ok) {
             // Thrown rather than printed: a 502/503/504/429 is as transient as a
             // reset and deserves the same retries, while a 400/401 must surface at
@@ -290,6 +311,13 @@ export class LLMClient {
             if (!message)
                 throw new Error("endpoint did not return a valid model completion");
             this.reasoningContent = message.reasoning_content ?? message.reasoning ?? "";
+            if (this.reasoningContent)
+                options.diagnosticObserver?.content("reasoning");
+            if (message.content)
+                options.diagnosticObserver?.content("text");
+            if (message.tool_calls?.length)
+                options.diagnosticObserver?.content("tool");
+            options.diagnosticObserver?.usageUpdate(body.usage);
             this.toolCalls = (message.tool_calls ?? []).map((call) => ({
                 id: call.id, name: call.function.name, arguments: call.function.arguments,
             }));
@@ -338,6 +366,7 @@ export class LLMClient {
                         continue;
                     }
                     const usage = chunk.usage;
+                    options.diagnosticObserver?.usageUpdate(usage);
                     if (usage) {
                         this.usage = {
                             prompt: usage.prompt_tokens ?? 0,
@@ -352,12 +381,18 @@ export class LLMClient {
                     // DeepSeek calls it reasoning_content; other compatible endpoints use
                     // the shorter `reasoning`. Neither is part of the visible reply.
                     const reasoning = delta.reasoning_content ?? delta.reasoning;
-                    if (typeof reasoning === "string" && reasoning)
+                    if (typeof reasoning === "string" && reasoning) {
+                        options.diagnosticObserver?.content("reasoning");
                         this.reasoningContent += reasoning;
+                    }
                     const content = delta.content;
-                    if (typeof content === "string" && content)
+                    if (typeof content === "string" && content) {
+                        options.diagnosticObserver?.content("text");
                         yield content;
+                    }
                     const toolCalls = delta.tool_calls;
+                    if (toolCalls?.length)
+                        options.diagnosticObserver?.content("tool");
                     if (toolCalls) {
                         for (const tc of toolCalls) {
                             const i = tc.index ?? 0;
@@ -486,7 +521,7 @@ export class LLMClient {
             headers,
             body: JSON.stringify(payload),
             signal: options.signal,
-        });
+        }, options.diagnosticObserver);
         if (!resp.ok) {
             // Thrown rather than printed: a 502/503/504/429 is as transient as a
             // reset and deserves the same retries, while a 400/401 must surface at
@@ -499,6 +534,13 @@ export class LLMClient {
             if (!Array.isArray(body.content))
                 throw new Error("endpoint did not return a valid model completion");
             this.captureAnthropicContent(body.content);
+            options.diagnosticObserver?.usageUpdate(body.usage);
+            if (this.reasoningContent)
+                options.diagnosticObserver?.content("reasoning");
+            if (this.toolCalls.length)
+                options.diagnosticObserver?.content("tool");
+            if (body.content.some(block => block.type === "text"))
+                options.diagnosticObserver?.content("text");
             this.finishReason = body.stop_reason ?? null;
             if (body.usage) {
                 const prompt = body.usage.input_tokens ?? 0;
@@ -546,6 +588,13 @@ export class LLMClient {
                     }
                     const event = chunk;
                     const type = event.type;
+                    options.diagnosticObserver?.usageUpdate(event.message?.usage ?? event.usage);
+                    if (event.content_block?.type === "tool_use" || event.delta?.partial_json)
+                        options.diagnosticObserver?.content("tool");
+                    if (event.delta?.thinking || event.content_block?.type === "thinking")
+                        options.diagnosticObserver?.content("reasoning");
+                    if (event.delta?.text || event.content_block?.text)
+                        options.diagnosticObserver?.content("text");
                     if (event.delta?.stop_reason)
                         this.finishReason = event.delta.stop_reason;
                     if (type === "error")

package/dist/llm/codeExecutor.d.ts

@@ -0,0 +1,14 @@
+import type { Executor, ExecuteResult, ResolvedProvider } from "@cloudflare/codemode/browser";
+interface Limits {
+    cpuMs: number;
+    memoryBytes: number;
+    idleMs: number;
+}
+/** The worker owns QuickJS; only named tool RPCs can reach the host. */
+export declare class LocalCodeExecutor implements Executor {
+    private signal?;
+    private limits;
+    constructor(signal?: AbortSignal | undefined, limits?: Partial<Limits>);
+    execute(code: string, providersOrFns: ResolvedProvider[] | Record<string, (...args: unknown[]) => Promise<unknown>>): Promise<ExecuteResult>;
+}
+export {};

package/dist/llm/codemode.d.ts

@@ -0,0 +1,15 @@
+import { type ToolDefinition } from "./tools.js";
+import type { PlanState } from "./plan.js";
+export declare const CODE_TOOL = "execute_ts";
+export declare class ProgramToolDenied extends Error {
+}
+interface ProgramOptions {
+    signal?: AbortSignal;
+    call(name: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<string>;
+    onPlan(plan: PlanState): void;
+    onStep(index: number, status: "active" | "done"): void;
+}
+export declare function getCodeToolDefinition(): ToolDefinition;
+/** Only the program's return, bounded logs and completion ledger enter LLM context. */
+export declare function executeCodeProgram(args: Record<string, unknown>, options: ProgramOptions): Promise<string>;
+export {};

package/dist/llm/context.d.ts

@@ -0,0 +1,29 @@
+import type { LLMClient, StreamOptions, UsageInfo } from "./client.js";
+import type { ToolDefinition } from "./tools.js";
+import { type TaskRuntime } from "./runtime.js";
+export interface ContextMessage {
+    role: string;
+    content?: string;
+    tool_calls?: unknown[];
+    tool_call_id?: string;
+}
+/** Spend only the root's reserved report request; local evidence remains the fallback. */
+export declare function finalTaskReport(runtime: TaskRuntime, createClient: () => LLMClient, onUsage?: (usage: UsageInfo) => void, messages?: readonly ContextMessage[]): Promise<string>;
+/** Context scheduling estimate for mixed ASCII/CJK; provider usage is also checked. */
+export declare function estimateTokens(value: unknown): number;
+export declare const DEFAULT_OUTPUT_TOKENS = 16384;
+export declare function outputAllowance(capacity: number): number;
+/** Reserve a byte-based upper estimate, including framing, when usage is unknown. */
+export declare function inputTokenBound(value: unknown): number;
+/** Compact complete assistant/tool groups before any request, including wrap-up. */
+export declare function prepareContext<T extends ContextMessage>(options: {
+    messages: T[];
+    tools: ToolDefinition[];
+    capacity: number;
+    lastPromptTokens?: number;
+    preserveBrief?: boolean;
+    createClient(): LLMClient;
+    stream?: StreamOptions;
+    onUsage?(usage: UsageInfo): void;
+    onProgress?(): void;
+}): Promise<void>;

package/dist/llm/diagnostics.d.ts

@@ -0,0 +1,91 @@
+export type DiagnosticRole = "main" | "planning" | "worker" | "verification" | "approval" | "compression" | "integration";
+export interface DiagnosticScope {
+    runId: string;
+    parentRunId?: string;
+    role: string;
+}
+export interface DiagnosticRequestContext {
+    request_id?: string;
+    task_id?: string;
+    role?: DiagnosticRole;
+}
+export interface DiagnosticEvent {
+    seq: number;
+    trace_id: string;
+    at_ms: number;
+    event: string;
+    mode?: string;
+    role?: string;
+    task_id?: string;
+    scope_run_id?: string;
+    parent_scope_run_id?: string;
+    data: Record<string, unknown>;
+}
+export declare const diagnosticHash: (value: unknown) => string;
+/** Opt-in metadata only. I/O failures and buffer pressure never change task decisions. */
+export declare class DiagnosticRecorder {
+    readonly file: string;
+    private options;
+    readonly traceId: string;
+    private began;
+    private sequence;
+    private identifiers;
+    private buffer;
+    private bufferedBytes;
+    private scheduled?;
+    private writing?;
+    private closing?;
+    private closed;
+    private unavailable;
+    private scopes;
+    dropped: number;
+    ioErrors: number;
+    bytesWritten: number;
+    enqueueMs: number;
+    writeMs: number;
+    constructor(file: string, options?: {
+        traceId?: string;
+        mode?: string;
+        source?: "offline_scripted_transport" | "runtime_transport";
+        maxBufferedBytes?: number;
+        flushIntervalMs?: number;
+    });
+    id(kind: string): string;
+    associate(scope: DiagnosticScope, context: {
+        role?: string;
+        task_id?: string;
+    }): void;
+    context(scope?: DiagnosticScope): {
+        role?: string;
+        task_id?: string;
+        scope_run_id?: string;
+        parent_scope_run_id?: string;
+    };
+    emit(event: string, data?: Record<string, unknown>, scope?: DiagnosticScope): void;
+    span(event: string, data?: Record<string, unknown>, scope?: DiagnosticScope): {
+        id: string;
+        end(extra?: Record<string, unknown>): void;
+    };
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+/** One logical stream, with distinct attempts and first reasoning/text/tool events. */
+export declare class DiagnosticRequest {
+    private trace;
+    private context;
+    private scope?;
+    readonly requestId: string;
+    private attemptId?;
+    private attemptNumber;
+    private first;
+    private usage;
+    constructor(trace: DiagnosticRecorder, context: DiagnosticRequestContext, scope?: DiagnosticScope | undefined);
+    private emit;
+    dispatch(body: string): void;
+    headers(status: number): void;
+    content(kind: "reasoning" | "text" | "tool"): void;
+    usageUpdate(value: unknown): void;
+    retry(delayMs: number): void;
+    private finishAttempt;
+    end(status: string): void;
+}

package/dist/llm/diagnostics.js

@@ -0,0 +1,242 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { performance } from "node:perf_hooks";
+export const diagnosticHash = (value) => createHash("sha256")
+    .update(typeof value === "string" ? value : JSON.stringify(value) ?? "null").digest("hex");
+const bytes = (value) => Buffer.byteLength(typeof value === "string" ? value : JSON.stringify(value) ?? "", "utf8");
+const stringFields = new Set(["request_id", "attempt_id", "wait_id", "span_id", "tool_id", "tool_name", "task_id", "verifies",
+    "engine_run_id", "scope_run_id", "parent_scope_run_id", "role", "status", "reason_code", "resource", "artifact_kind", "mode", "provider", "source"]);
+function safeData(data, depth = 0) {
+    const result = Object.create(null);
+    for (const [key, value] of Object.entries(data)) {
+        if (typeof value === "number" && Number.isFinite(value) || typeof value === "boolean" || value === null)
+            result[key] = value;
+        else if (typeof value === "string" && stringFields.has(key))
+            result[key] = value.slice(0, 160);
+        else if (typeof value === "string" && key.endsWith("_hash") && /^[a-f\d]{64}$/.test(value))
+            result[key] = value;
+        else if (Array.isArray(value) && ["dependencies", "blocker_ids"].includes(key))
+            result[key] = value.slice(0, 128).filter(v => typeof v === "string" && /^[a-zA-Z\d_.:-]{1,100}$/.test(v));
+        else if (value && typeof value === "object" && !Array.isArray(value) && depth < 2)
+            result[key] = safeData(value, depth + 1);
+    }
+    return result;
+}
+/** Opt-in metadata only. I/O failures and buffer pressure never change task decisions. */
+export class DiagnosticRecorder {
+    file;
+    options;
+    traceId;
+    began = performance.now();
+    sequence = 0;
+    identifiers = 0;
+    buffer = [];
+    bufferedBytes = 0;
+    scheduled;
+    writing;
+    closing;
+    closed = false;
+    unavailable = false;
+    scopes = new Map();
+    dropped = 0;
+    ioErrors = 0;
+    bytesWritten = 0;
+    enqueueMs = 0;
+    writeMs = 0;
+    constructor(file, options = {}) {
+        this.file = file;
+        this.options = options;
+        this.traceId = options.traceId ?? randomUUID();
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+            fs.writeFileSync(file, "", { flag: "wx", mode: 0o600 });
+        }
+        catch {
+            this.ioErrors++;
+            this.unavailable = true;
+        }
+        this.emit("trace_start", { mode: options.mode ?? "unknown", source: options.source ?? "runtime_transport" });
+    }
+    id(kind) { return `${kind}-${++this.identifiers}`; }
+    associate(scope, context) {
+        this.scopes.set(scope.runId, { ...this.scopes.get(scope.runId), ...context, parent_scope_run_id: scope.parentRunId });
+    }
+    context(scope) {
+        if (!scope)
+            return {};
+        let record = this.scopes.get(scope.runId), parent = scope.parentRunId;
+        for (let depth = 0; !record?.task_id && parent && depth < 32; depth++) {
+            const inherited = this.scopes.get(parent);
+            if (inherited?.task_id)
+                record = { ...record, task_id: inherited.task_id };
+            parent = inherited?.parent_scope_run_id;
+        }
+        return { role: record?.role ?? scope.role, task_id: record?.task_id, scope_run_id: scope.runId, parent_scope_run_id: scope.parentRunId };
+    }
+    emit(event, data = {}, scope) {
+        if (this.closed)
+            return;
+        if (this.unavailable) {
+            this.dropped++;
+            return;
+        }
+        const started = performance.now();
+        const context = this.context(scope);
+        const sanitized = safeData(data);
+        const record = { seq: ++this.sequence, trace_id: this.traceId, at_ms: performance.now() - this.began,
+            event, mode: this.options.mode, ...context,
+            ...(typeof sanitized.role === "string" ? { role: sanitized.role } : {}),
+            ...(typeof sanitized.task_id === "string" ? { task_id: sanitized.task_id } : {}), data: sanitized };
+        const line = JSON.stringify(record) + "\n", size = Buffer.byteLength(line);
+        if (size > 8192 || this.bufferedBytes + size > (this.options.maxBufferedBytes ?? 512_000))
+            this.dropped++;
+        else {
+            this.buffer.push(line);
+            this.bufferedBytes += size;
+        }
+        this.enqueueMs += performance.now() - started;
+        if (!this.scheduled && !this.writing)
+            this.scheduled = setTimeout(() => { this.scheduled = undefined; void this.flush(); }, this.options.flushIntervalMs ?? 25);
+    }
+    span(event, data = {}, scope) {
+        const spanId = this.id("span"), began = performance.now();
+        this.emit(`${event}_start`, { ...data, span_id: spanId }, scope);
+        let ended = false;
+        return { id: spanId, end: extra => { if (!ended) {
+                ended = true;
+                this.emit(`${event}_end`, { ...data, ...extra, span_id: spanId, duration_ms: performance.now() - began }, scope);
+            } } };
+    }
+    async flush() {
+        if (this.writing)
+            return this.writing;
+        if (!this.buffer.length || this.unavailable)
+            return;
+        const content = this.buffer.join("");
+        this.buffer = [];
+        this.bufferedBytes = 0;
+        const began = performance.now();
+        this.writing = (async () => {
+            try {
+                // Deleting a run must not cause a late write to recreate it.
+                if (!fs.existsSync(this.file)) {
+                    this.unavailable = true;
+                    this.dropped += content.split("\n").length - 1;
+                    return;
+                }
+                const handle = await fs.promises.open(this.file, "r+");
+                try {
+                    const contentBytes = Buffer.from(content), start = (await handle.stat()).size;
+                    for (let offset = 0; offset < contentBytes.length;) {
+                        const written = await handle.write(contentBytes, offset, contentBytes.length - offset, start + offset);
+                        if (!written.bytesWritten)
+                            throw new Error("trace write made no progress");
+                        offset += written.bytesWritten;
+                    }
+                }
+                finally {
+                    await handle.close();
+                }
+                this.bytesWritten += Buffer.byteLength(content);
+            }
+            catch {
+                this.ioErrors++;
+                this.unavailable = true;
+            }
+            finally {
+                this.writeMs += performance.now() - began;
+            }
+        })();
+        try {
+            await this.writing;
+        }
+        finally {
+            this.writing = undefined;
+            if (this.buffer.length && !this.closed && !this.unavailable && !this.scheduled)
+                this.scheduled = setTimeout(() => { this.scheduled = undefined; void this.flush(); }, this.options.flushIntervalMs ?? 25);
+        }
+    }
+    close() {
+        if (this.closing)
+            return this.closing;
+        this.emit("trace_summary", { dropped_events: this.dropped, io_errors: this.ioErrors, enqueue_ms: this.enqueueMs, write_ms: this.writeMs });
+        this.closed = true;
+        if (this.scheduled) {
+            clearTimeout(this.scheduled);
+            this.scheduled = undefined;
+        }
+        this.closing = (async () => { await this.writing; while (this.buffer.length && !this.unavailable)
+            await this.flush(); })();
+        return this.closing;
+    }
+}
+/** One logical stream, with distinct attempts and first reasoning/text/tool events. */
+export class DiagnosticRequest {
+    trace;
+    context;
+    scope;
+    requestId;
+    attemptId;
+    attemptNumber = 0;
+    first = new Set();
+    usage = {};
+    constructor(trace, context, scope) {
+        this.trace = trace;
+        this.context = context;
+        this.scope = scope;
+        this.requestId = context.request_id ?? trace.id("request");
+        this.emit("model_stream_start");
+    }
+    emit(event, data = {}) {
+        this.trace.emit(event, { request_id: this.requestId, role: this.context.role ?? "main", task_id: this.context.task_id, ...data }, this.scope);
+    }
+    dispatch(body) {
+        this.finishAttempt("abandoned");
+        this.attemptId = this.trace.id("attempt");
+        this.attemptNumber++;
+        this.first.clear();
+        this.usage = {};
+        const payload = JSON.parse(body);
+        const messages = Array.isArray(payload.messages) ? payload.messages : [];
+        this.emit("provider_dispatch", { attempt_id: this.attemptId, attempt: this.attemptNumber, payload_bytes: bytes(body), payload_hash: diagnosticHash(body),
+            system_bytes: bytes(payload.system ?? "") + messages.filter(m => m.role === "system").reduce((n, m) => n + bytes(m), 0),
+            user_bytes: messages.filter(m => m.role === "user").reduce((n, m) => n + bytes(m), 0),
+            assistant_bytes: messages.filter(m => m.role === "assistant").reduce((n, m) => n + bytes(m), 0),
+            tool_result_bytes: messages.filter(m => m.role === "tool").reduce((n, m) => n + bytes(m), 0),
+            reasoning_echo_bytes: messages.reduce((n, m) => n + bytes(m.reasoning_content ?? ""), 0),
+            tool_schema_bytes: bytes(payload.tools ?? []), streaming: payload.stream !== false });
+    }
+    headers(status) { this.emit("provider_headers", { attempt_id: this.attemptId, http_status: status }); }
+    content(kind) {
+        if (!this.first.has("content")) {
+            this.first.add("content");
+            this.emit("provider_first_content", { attempt_id: this.attemptId });
+        }
+        if (!this.first.has(kind)) {
+            this.first.add(kind);
+            this.emit(`provider_first_${kind}`, { attempt_id: this.attemptId });
+        }
+    }
+    usageUpdate(value) {
+        if (!value || typeof value !== "object")
+            return;
+        const v = value, prompt = v.prompt_tokens ?? v.input_tokens, completion = v.completion_tokens ?? v.output_tokens;
+        const details = v.prompt_tokens_details;
+        const completionDetails = v.completion_tokens_details;
+        const entries = { input_tokens: prompt, output_tokens: completion, cached_input_tokens: details?.cached_tokens ?? v.prompt_cache_hit_tokens ?? v.cache_read_input_tokens,
+            reasoning_tokens: completionDetails?.reasoning_tokens };
+        for (const [key, count] of Object.entries(entries))
+            if (typeof count === "number" && Number.isFinite(count))
+                this.usage[key] = count;
+    }
+    retry(delayMs) { this.finishAttempt("retry"); this.emit("model_retry_wait", { delay_ms: delayMs }); }
+    finishAttempt(status) {
+        if (!this.attemptId)
+            return;
+        this.emit("provider_attempt_end", { attempt_id: this.attemptId, status, input_tokens: this.usage.input_tokens ?? null,
+            output_tokens: this.usage.output_tokens ?? null, cached_input_tokens: this.usage.cached_input_tokens ?? null, reasoning_tokens: this.usage.reasoning_tokens ?? null });
+        this.attemptId = undefined;
+    }
+    end(status) { this.finishAttempt(status); this.emit("model_stream_end", { status }); }
+}