@jungjaehoon/mama-core 2.4.1 → 4.0.0

package/dist/runtime/native-prompt.js

@@ -0,0 +1,496 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNativePrompt = runNativePrompt;
+const types_js_1 = require("./drivers/types.js");
+const debug_logger_js_1 = require("../debug-logger.js");
+const logger = new debug_logger_js_1.DebugLogger('turn');
+const turn_text_js_1 = require("./turn-text.js");
+/** A model-runner failure, said in the loop's own error vocabulary. */
+const MODEL_RUNNER_AGENT_ERROR_CODES = {
+    timeout: 'NETWORK_ERROR',
+    crash: 'CLI_ERROR',
+    context_overflow: 'MAX_TOKENS',
+    auth_failure: 'AUTH_ERROR',
+    rate_limit: 'RATE_LIMIT',
+    unknown: 'CLI_ERROR',
+};
+/**
+ * Submit one native request and observe its completed exchanges and final result.
+ * `carry` is read and written: the caller reads the final state off it.
+ */
+async function runNativePrompt(carry, context, request, host) {
+    const { channelKey, claudeNativeTools, effectiveSessionPolicyFingerprint, restrictedReadRoots, nativeCwd, history, hostToolBridge, isCodex, isDurableRuntime, nativeEffects, ownedModelRunId, standingPolicy, systemPrompt, reanchor, resumeInstructions, runScope, toolExecutionContext, totalUsage, tracksSessionPolicy, } = context;
+    // The eight that change are taken out of `carry` and put back in a finally, so the
+    // body below is the same text it was inside the class. A throw still reports the
+    // turn it reached.
+    let { turn, stopReason, stoppedBy, budgetTokens, resolvedCliSessionId, sessionIsNew } = carry;
+    try {
+        turn++;
+        {
+            let response;
+            const ext = runScope.streamCallbacks;
+            let attemptReportedError;
+            let nativeReceipt;
+            let nativeDispatch;
+            const callbacks = {
+                onInputDispatch: (input) => {
+                    ext?.onInputDispatch?.(input);
+                    nativeDispatch = input;
+                },
+                onAccepted: (receipt) => {
+                    nativeReceipt = receipt;
+                    ext?.onAccepted?.(receipt);
+                },
+                onDelta: (text) => {
+                    ext?.onDelta?.(text);
+                },
+                onToolUse: (name, input) => {
+                    nativeEffects.started(name, input);
+                    ext?.onToolUse?.(name, input);
+                },
+                onToolComplete: (name, toolUseId, isError, outcome) => {
+                    nativeEffects.settled(name, toolUseId, isError, outcome);
+                    if (outcome)
+                        ext?.onToolComplete?.(name, toolUseId, isError, outcome);
+                    else
+                        ext?.onToolComplete?.(name, toolUseId, isError);
+                },
+                // A spawn is an admission, not an external effect: forwarded verbatim with NO
+                // nativeEffects call, so it never writes a `native_tool` ledger row and never
+                // makes the occurrence unsafe to replay.
+                onSubagentStart: (info) => {
+                    ext?.onSubagentStart?.(info);
+                },
+                onFollowUp: (info) => {
+                    ext?.onFollowUp?.(info);
+                },
+                onFinal: (finalResponse) => {
+                    ext?.onFinal?.(finalResponse);
+                },
+                onError: (error) => {
+                    // A model runner can emit onError before rejecting. Hold it until
+                    // AgentLoop knows whether the attempt is terminal so a successful
+                    // one-time session recovery does not leak a false failure event.
+                    attemptReportedError = error;
+                },
+            };
+            let piResult;
+            // Claude: first turn uses --session-id and injects the system prompt; later turns --resume
+            // Codex: resumeSession controls durable session reset/continuation.
+            let shouldResume = isDurableRuntime
+                ? turn > 1 || (request.freshSession === true ? false : (request.resumeSession ?? true))
+                : !sessionIsNew || turn > 1 || (standingPolicy && request.resumeSession === true);
+            let requestSystemPrompt = systemPrompt;
+            let provisionalDurableSessionId;
+            // All three backends preserve context and receive only the new user message.
+            const basePromptText = host.formatLastMessageOnly(history);
+            const preparePrompt = context.prepareSessionContent
+                ? async (session) => {
+                    const content = await context.prepareSessionContent(session);
+                    const input = [...history].reverse().find((message) => message.role === 'user');
+                    if (!input)
+                        throw new Error('Native session content requires an input message');
+                    input.content = content;
+                    console.log(`[NativeTurn] [${host.backend}] ${channelKey} (${session.isNewSession ? 'NEW' : 'CONTINUE'} native session)`);
+                    return host.formatLastMessageOnly(history);
+                }
+                : undefined;
+            let promptText = basePromptText;
+            const promptStart = Date.now();
+            const throwFinalCliError = (error) => {
+                const normalizedError = error instanceof Error ? error : new Error(String(error));
+                const modelRunnerErrorCode = normalizedError instanceof types_js_1.ModelRunnerError
+                    ? MODEL_RUNNER_AGENT_ERROR_CODES[normalizedError.code]
+                    : undefined;
+                const errorType = normalizedError instanceof types_js_1.ClaudeToolStreamProtocolError
+                    ? normalizedError.code
+                    : normalizedError instanceof types_js_1.HostToolTerminalError
+                        ? normalizedError.terminalCode
+                        : (modelRunnerErrorCode ?? 'CLI_ERROR');
+                host.onMetric?.('prompt_error', 1, {
+                    backend: host.backend,
+                    error_type: errorType,
+                });
+                try {
+                    ext?.onError?.(attemptReportedError ?? normalizedError);
+                }
+                catch (callbackError) {
+                    logger.warn(`External onError callback failed: ${callbackError instanceof Error ? callbackError.message : String(callbackError)}`);
+                }
+                if (normalizedError instanceof types_js_1.HostToolTerminalError) {
+                    throw new types_js_1.AgentError(normalizedError.message, normalizedError.terminalCode, normalizedError, false);
+                }
+                if (normalizedError instanceof types_js_1.HostToolAbortError) {
+                    throw new types_js_1.AgentError(normalizedError.message, 'CLI_ERROR', normalizedError, false);
+                }
+                if (normalizedError instanceof types_js_1.NativeInputUncertainError) {
+                    throw new types_js_1.AgentError(normalizedError.message, 'CLI_ERROR', normalizedError, false);
+                }
+                if (normalizedError instanceof types_js_1.ClaudeToolStreamProtocolError) {
+                    throw new types_js_1.AgentError(normalizedError.message, normalizedError.code, normalizedError, false);
+                }
+                throw new types_js_1.AgentError(`CLI error: ${normalizedError.message}`, modelRunnerErrorCode ?? 'CLI_ERROR', normalizedError, normalizedError instanceof types_js_1.ModelRunnerError ? normalizedError.retryable : true);
+            };
+            const appendCompletedToolExchanges = (exchanges) => {
+                for (const exchange of exchanges) {
+                    history.push({ role: 'assistant', content: [exchange.toolUse] });
+                    runScope.onTurn?.({
+                        turn,
+                        role: 'assistant',
+                        content: [exchange.toolUse],
+                        stopReason: 'tool_use',
+                    });
+                    history.push({ role: 'user', content: [exchange.toolResult] });
+                    runScope.onTurn?.({
+                        turn,
+                        role: 'user',
+                        content: [exchange.toolResult],
+                    });
+                }
+            };
+            try {
+                const durablePolicyStatus = tracksSessionPolicy && turn === 1 && (shouldResume || standingPolicy)
+                    ? host.agent.getSessionPolicyStatus?.({
+                        model: request.model,
+                        resumeSession: true,
+                        systemPrompt: requestSystemPrompt,
+                        sessionKey: channelKey,
+                        sessionPolicyFingerprint: effectiveSessionPolicyFingerprint,
+                        restrictedReadRoots,
+                        cwd: nativeCwd,
+                        sessionId: resolvedCliSessionId ?? undefined,
+                        requestTimeout: request.requestTimeoutMs,
+                        // Enforced INSIDE the codex turn (usage events), see CodexAppServerProcess.
+                        runTokenBudget: host.runTokenBudget,
+                        hostToolBridge,
+                    })
+                    : undefined;
+                if (durablePolicyStatus === 'mismatch' || durablePolicyStatus === 'missing') {
+                    console.log(`[turn] ${host.backend} durable session ${durablePolicyStatus}; ` +
+                        'opening the full policy before model request');
+                    if (host.backend === 'claude' && durablePolicyStatus === 'mismatch') {
+                        if (!host.agent.resetSession) {
+                            throw new Error('Claude model runner cannot retire a stale policy session');
+                        }
+                        await host.agent.resetSession(resolvedCliSessionId ?? undefined);
+                    }
+                    const newSessionId = host.sessionPool.resetSession(channelKey);
+                    request.onCliSessionReset?.(newSessionId);
+                    resolvedCliSessionId = newSessionId;
+                    provisionalDurableSessionId = newSessionId;
+                    try {
+                        // Recovery is asked for only after the backend proves replacement is
+                        // required, never from host pool state.
+                        const reanchored = await reanchor?.();
+                        if (reanchored !== undefined) {
+                            requestSystemPrompt = reanchored;
+                        }
+                    }
+                    catch (rebuildError) {
+                        host.sessionPool.invalidateSession(channelKey, newSessionId);
+                        provisionalDurableSessionId = undefined;
+                        attemptReportedError =
+                            rebuildError instanceof Error ? rebuildError : new Error(String(rebuildError));
+                        throw rebuildError;
+                    }
+                    shouldResume = false;
+                }
+                promptText = basePromptText;
+                piResult = await host.agent.prompt(promptText, callbacks, {
+                    preparePrompt,
+                    model: request.model,
+                    nativeInputId: request.nativeInputId,
+                    resumeSession: shouldResume,
+                    systemPrompt: requestSystemPrompt,
+                    resumeInstructions,
+                    promptTelemetry: {
+                        kind: request.promptKind ?? (request.source === 'operator' ? 'scheduled' : 'chat'),
+                        brief: request.promptBrief ?? 'omitted',
+                    },
+                    sessionKey: channelKey,
+                    sessionPolicyFingerprint: effectiveSessionPolicyFingerprint,
+                    restrictedReadRoots,
+                    cwd: nativeCwd,
+                    sessionId: resolvedCliSessionId ?? undefined,
+                    // Per-run request timeout (operator worker runs); undefined leaves
+                    // the pool's construction-time default untouched (chat).
+                    requestTimeout: request.requestTimeoutMs,
+                    runTokenBudget: host.runTokenBudget,
+                    hostToolBridge,
+                    toolExecutionContext,
+                    ...(host.backend === 'claude' ? { tools: claudeNativeTools } : {}),
+                });
+                provisionalDurableSessionId = undefined;
+            }
+            catch (error) {
+                if (provisionalDurableSessionId) {
+                    host.sessionPool.invalidateSession(channelKey, provisionalDurableSessionId);
+                    provisionalDurableSessionId = undefined;
+                }
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error(`[turn] ${host.backend} CLI error:`, errorMessage);
+                // A codex turn interrupted by the run budget is a host decision, not a failure:
+                // stop here with what was collected and let the host record the receipt.
+                if (error?.code === 'RUN_BUDGET_STOP' ||
+                    errorMessage.startsWith('run budget stop:')) {
+                    stoppedBy = 'budget';
+                    const stoppedUsage = error.usage;
+                    if (stoppedUsage) {
+                        totalUsage.input_tokens += stoppedUsage.input_tokens;
+                        totalUsage.output_tokens += stoppedUsage.output_tokens;
+                        budgetTokens += (0, turn_text_js_1.countBudgetTokens)(stoppedUsage, host.backend);
+                        try {
+                            host.onTokenUsage?.({
+                                channel_key: channelKey,
+                                agent_id: request.agentContext?.roleName || host.model,
+                                input_tokens: stoppedUsage.input_tokens,
+                                output_tokens: stoppedUsage.output_tokens,
+                                cache_read_tokens: stoppedUsage.cache_read_input_tokens || 0,
+                                cost_usd: 0,
+                            });
+                        }
+                        catch {
+                            // Recording failures must never mask the stop itself.
+                        }
+                    }
+                    budgetTokens = Math.max(budgetTokens, host.runTokenBudget);
+                    try {
+                        host.onBudgetStop?.({
+                            channelKey,
+                            modelRunId: ownedModelRunId ?? request.modelRunId ?? null,
+                            agentId: request.agentContext?.roleName,
+                            budgetTokens,
+                            runTokenBudget: host.runTokenBudget,
+                            turns: turn,
+                        });
+                    }
+                    catch {
+                        // Receipt failures must never mask the stop itself.
+                    }
+                    return;
+                }
+                if (error instanceof types_js_1.HostToolTerminalError && error.completedToolExchanges?.length) {
+                    appendCompletedToolExchanges(error.completedToolExchanges);
+                    throwFinalCliError(error);
+                }
+                if (error instanceof types_js_1.HostToolAbortError && error.completedToolExchanges.length > 0) {
+                    appendCompletedToolExchanges(error.completedToolExchanges);
+                    throwFinalCliError(error);
+                }
+                if (nativeReceipt || nativeDispatch) {
+                    throwFinalCliError(new types_js_1.NativeInputUncertainError('Native input dispatch began; reconcile its result before replay', (nativeReceipt ?? nativeDispatch), error));
+                }
+                // Check if this is a recoverable session error
+                // 1. "No conversation found" - CLI session was lost (daemon restart, timeout)
+                // 2. "Session ID already in use" - concurrent request conflict
+                // 3. "Prompt is too long" - session context exceeded API limits
+                const isSessionNotFound = errorMessage.includes('No conversation found with session ID');
+                const isSessionInUse = errorMessage.includes('is already in use');
+                const isPromptTooLong = (error instanceof types_js_1.ModelRunnerError && error.code === 'context_overflow') ||
+                    errorMessage.includes('Prompt is too long') ||
+                    errorMessage.includes('prompt is too long') ||
+                    errorMessage.includes('request_too_large') ||
+                    errorMessage.includes('context window') ||
+                    errorMessage.includes('context_length_exceeded');
+                const isCodexPolicyMismatch = errorMessage.includes('Codex app-server thread policy mismatch; reset the session explicitly');
+                // 4. API 400 on a resumed session whose stored transcript carries an
+                //    empty content block (live incident 2026-07-27: sonnet emitted an
+                //    empty thinking block, the CLI persisted it, and every subsequent
+                //    replay of that session died with this 400). The transcript is
+                //    unrecoverable - only a fresh session heals it.
+                const isCorruptTranscript = errorMessage.includes('text content blocks must be non-empty');
+                const canRecoverSession = error instanceof types_js_1.NativeSessionUnavailableError ||
+                    (isCodex && isCodexPolicyMismatch) ||
+                    (!isCodex &&
+                        (isSessionNotFound || isSessionInUse || isPromptTooLong || isCorruptTranscript));
+                const nativeFailure = nativeEffects.failure(error, canRecoverSession);
+                if (nativeFailure !== error) {
+                    throw nativeFailure;
+                }
+                if (canRecoverSession) {
+                    const reason = isCodexPolicyMismatch
+                        ? 'policy mismatch'
+                        : error instanceof types_js_1.NativeSessionUnavailableError
+                            ? 'native context missing'
+                            : isSessionNotFound
+                                ? 'not found in CLI'
+                                : isSessionInUse
+                                    ? 'already in use'
+                                    : isCorruptTranscript
+                                        ? 'transcript corrupt (empty content block)'
+                                        : 'prompt too long (context overflow)';
+                    console.log(`[turn] Session ${reason}, retrying with new session`);
+                    // Reset session in pool so it creates a new one
+                    const newSessionId = host.sessionPool.resetSession(channelKey);
+                    request.onCliSessionReset?.(newSessionId);
+                    // Per-call routing: hand the new id to this prompt() and update the
+                    // resolved id so later turns follow it - no shared-adapter mutation.
+                    resolvedCliSessionId = newSessionId;
+                    // A recoverable durable-session error can occur on a resumed
+                    // native session whose per-call prompt is intentionally minimal.
+                    // Rebuild the full policy before opening every replacement session.
+                    let resetSystemPrompt = systemPrompt;
+                    try {
+                        // Discard the recoverable first-attempt error before any reset
+                        // preparation. A prompt rebuild or retry failure must surface
+                        // its own final error, never the mismatch that triggered it.
+                        attemptReportedError = undefined;
+                        const reanchoredAfterReset = await reanchor?.();
+                        if (reanchoredAfterReset !== undefined) {
+                            resetSystemPrompt = reanchoredAfterReset;
+                        }
+                        promptText = basePromptText;
+                        piResult = await host.agent.prompt(promptText, callbacks, {
+                            preparePrompt,
+                            model: request.model,
+                            nativeInputId: request.nativeInputId,
+                            resumeSession: false, // Force new session
+                            systemPrompt: resetSystemPrompt,
+                            sessionKey: channelKey,
+                            sessionPolicyFingerprint: effectiveSessionPolicyFingerprint,
+                            restrictedReadRoots,
+                            cwd: nativeCwd,
+                            sessionId: newSessionId,
+                            // Carry the per-run timeout onto the reset session too.
+                            requestTimeout: request.requestTimeoutMs,
+                            runTokenBudget: host.runTokenBudget,
+                            hostToolBridge,
+                            toolExecutionContext,
+                            ...(host.backend === 'claude' ? { tools: claudeNativeTools } : {}),
+                        });
+                    }
+                    catch (retryError) {
+                        console.error(`[turn] ${host.backend} reset retry failed:`, retryError instanceof Error ? retryError.message : String(retryError));
+                        // resetSession() creates and locks a replacement pool entry.
+                        // A failed rebuild/retry must remove it entirely; otherwise the
+                        // next native turn sees isNew=false and can persist a
+                        // minimal resume prompt as the replacement thread's base policy.
+                        host.sessionPool.invalidateSession(channelKey, newSessionId);
+                        throwFinalCliError(retryError);
+                    }
+                    // Prepend reset notice so user knows context was lost
+                    if (isPromptTooLong && piResult?.response) {
+                        piResult.response = `\u26a0\ufe0f Session reset: The previous conversation was too long, starting a new session.\n\n${piResult.response}`;
+                    }
+                    console.log(`[turn] Retry successful with new session: ${newSessionId}`);
+                }
+                else {
+                    throwFinalCliError(error);
+                }
+            }
+            if (!piResult) {
+                return throwFinalCliError(new Error('Model runner returned no prompt result'));
+            }
+            // Emit one terminal metric per prompt turn, including recovered calls.
+            host.onMetric?.('prompt_latency_ms', Date.now() - promptStart, {
+                backend: host.backend,
+                turn: String(turn),
+            });
+            // After first successful call, mark session as not new for subsequent turns
+            if (turn === 1) {
+                sessionIsNew = false;
+            }
+            const contentBlocks = [];
+            if (piResult.response?.trim())
+                contentBlocks.push({ type: 'text', text: piResult.response });
+            // eslint-disable-next-line prefer-const
+            response = {
+                id: `msg_${Date.now()}`,
+                type: 'message',
+                role: 'assistant',
+                content: contentBlocks,
+                model: host.model,
+                stop_reason: 'end_turn',
+                stop_sequence: null,
+                usage: piResult.usage,
+            };
+            // Update usage
+            totalUsage.input_tokens += response.usage.input_tokens;
+            totalUsage.output_tokens += response.usage.output_tokens;
+            budgetTokens += (0, turn_text_js_1.countBudgetTokens)(response.usage, host.backend);
+            // Record token usage
+            if (host.onTokenUsage) {
+                try {
+                    host.onTokenUsage({
+                        channel_key: channelKey,
+                        agent_id: request.agentContext?.roleName || host.model, // Use roleName if available, else model
+                        input_tokens: response.usage.input_tokens,
+                        output_tokens: response.usage.output_tokens,
+                        cache_read_tokens: response.usage.cache_read_input_tokens || 0, // No longer needs 'as any' cast
+                        cost_usd: piResult.cost_usd || 0,
+                    });
+                }
+                catch {
+                    // Ignore recording errors - never break the agent loop
+                }
+            }
+            // Preserve the SessionPool usage-status contract. Billing telemetry is
+            // recorded above; durable runtimes own model-aware compaction.
+            host.sessionPool.updateTokens(channelKey, response.usage.input_tokens, host.backend);
+            // Claude's MCP server may already have executed these tool calls while the
+            // prompt was streaming. Preserve the observed exchange in conversation
+            // order, but never execute the observed tool_use again.
+            // Replaying a completed mutation would turn a transport observation into a
+            // second host-side effect.
+            if (Array.isArray(piResult.completedToolExchanges)) {
+                appendCompletedToolExchanges(piResult.completedToolExchanges);
+            }
+            // The local MCP server can complete a mutation and still report an
+            // indeterminate terminal outcome. Preserve the paired exchange above
+            // for auditability, then fail this turn without sending it through the
+            // ordinary host-tool loop or retrying the prompt.
+            if (piResult.terminalError) {
+                throwFinalCliError(new types_js_1.HostToolTerminalError(piResult.terminalError.code, piResult.terminalError.message));
+            }
+            if (piResult.toolUseBlocks?.length) {
+                throwFinalCliError(new types_js_1.ClaudeToolStreamProtocolError('Unresolved native tool calls cannot be executed by a host model loop'));
+            }
+            // Add assistant response to history
+            history.push({
+                role: 'assistant',
+                content: response.content,
+            });
+            // Notify turn callback
+            runScope.onTurn?.({
+                turn,
+                role: 'assistant',
+                content: response.content,
+                stopReason: response.stop_reason,
+                usage: response.usage,
+            });
+            stopReason = response.stop_reason;
+            // Per-run budget: checked after this turn's usage and before the next dispatch, so
+            // the budget is never exceeded by more than one turn. The partial response so far is
+            // returned, and the host records the receipt.
+            if (host.runTokenBudget > 0 && budgetTokens >= host.runTokenBudget) {
+                stoppedBy = 'budget';
+                console.warn(`[turn] run budget stop: ${budgetTokens} >= ${host.runTokenBudget} tokens after turn ${turn} (${channelKey})`);
+                try {
+                    host.onBudgetStop?.({
+                        channelKey,
+                        modelRunId: ownedModelRunId ?? request.modelRunId ?? null,
+                        agentId: request.agentContext?.roleName,
+                        budgetTokens,
+                        runTokenBudget: host.runTokenBudget,
+                        turns: turn,
+                    });
+                }
+                catch {
+                    // Receipt failures must never mask the stop itself.
+                }
+                return;
+            }
+        }
+    }
+    finally {
+        Object.assign(carry, {
+            turn,
+            stopReason,
+            stoppedBy,
+            budgetTokens,
+            resolvedCliSessionId,
+            sessionIsNew,
+        });
+    }
+}
+//# sourceMappingURL=native-prompt.js.map

package/dist/runtime/native-session.d.ts

@@ -0,0 +1,10 @@
+/** Shared native protocol, session lifetime and execution observations. */
+export * from './native-effect-observer.js';
+export * from './post-tool-handler.js';
+export * from './agent-event-bus.js';
+export * from './runtime-process.js';
+export * from './turn-text.js';
+export * from './native-prompt.js';
+export * from './native-turn.js';
+export type { NativeInputReceipt } from './drivers/types.js';
+//# sourceMappingURL=native-session.d.ts.map

package/dist/{agent-graph/index.js → runtime/native-session.js}

@@ -14,9 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types.js"), exports);
-__exportStar(require("./errors.js"), exports);
-__exportStar(require("./entity-resolve.js"), exports);
-__exportStar(require("./graph-query.js"), exports);
-__exportStar(require("./alias-write.js"), exports);
-//# sourceMappingURL=index.js.map
+/** Shared native protocol, session lifetime and execution observations. */
+__exportStar(require("./native-effect-observer.js"), exports);
+__exportStar(require("./post-tool-handler.js"), exports);
+__exportStar(require("./agent-event-bus.js"), exports);
+__exportStar(require("./runtime-process.js"), exports);
+__exportStar(require("./turn-text.js"), exports);
+__exportStar(require("./native-prompt.js"), exports);
+__exportStar(require("./native-turn.js"), exports);
+//# sourceMappingURL=native-session.js.map

package/dist/runtime/native-tool-trace-observer.d.ts

@@ -0,0 +1,5 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { NativeEffectObserver } from './native-effect-observer.js';
+/** Native harness notifications are observations; persistence never authorizes execution. */
+export declare function createNativeToolTraceObserver(adapter: Pick<DatabaseAdapter, 'prepare'>, modelRunId: string): NativeEffectObserver;
+//# sourceMappingURL=native-tool-trace-observer.d.ts.map

package/dist/runtime/native-tool-trace-observer.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNativeToolTraceObserver = createNativeToolTraceObserver;
+const node_crypto_1 = require("node:crypto");
+const tool_trace_store_js_1 = require("./tool-trace-store.js");
+const trace_summary_js_1 = require("./trace-summary.js");
+/** Native harness notifications are observations; persistence never authorizes execution. */
+function createNativeToolTraceObserver(adapter, modelRunId) {
+    const calls = new Map();
+    let warned = false;
+    const failed = () => {
+        if (!warned)
+            console.warn('[NativeToolTrace] observation storage failed');
+        warned = true;
+    };
+    const settle = (callId, status) => {
+        const call = calls.get(callId);
+        if (!call || call.settled)
+            return;
+        try {
+            adapter
+                .prepare('UPDATE tool_traces SET execution_status = ?, duration_ms = ? WHERE trace_id = ?')
+                .run(status, Math.max(0, Date.now() - call.startedAt), call.traceId);
+            call.settled = status !== 'unknown';
+        }
+        catch {
+            failed();
+        }
+    };
+    return {
+        started(name, input) {
+            const callId = typeof input.nativeToolUseId === 'string' ? input.nativeToolUseId : (0, node_crypto_1.randomUUID)();
+            if (calls.has(callId))
+                return;
+            const call = {
+                traceId: `tr_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`,
+                startedAt: Date.now(),
+                settled: false,
+            };
+            calls.set(callId, call);
+            void (0, tool_trace_store_js_1.appendToolTrace)(adapter, {
+                trace_id: call.traceId,
+                model_run_id: modelRunId,
+                gateway_call_id: callId,
+                tool_name: name,
+                input_summary: (0, trace_summary_js_1.traceSummary)(input),
+                execution_status: 'running',
+                duration_ms: 0,
+                created_at: call.startedAt,
+            }).catch(failed);
+        },
+        settled(_name, callId, isError, outcome) {
+            settle(callId, outcome ?? (isError ? 'failed' : 'completed'));
+        },
+        interrupted() {
+            for (const callId of calls.keys())
+                settle(callId, 'unknown');
+        },
+        finished() {
+            for (const callId of calls.keys())
+                settle(callId, 'unknown');
+        },
+    };
+}
+//# sourceMappingURL=native-tool-trace-observer.js.map