experimental-ash 0.25.2 → 0.27.0

package/dist/src/harness/tool-loop.js

@@ -1,877 +1 @@
-import { context as otelContext, trace, } from "#compiled/@opentelemetry/api/index.js";
-import { isStepCount, ToolLoopAgent, } from "ai";
-import { resolveInstalledPackageInfo } from "#internal/application/package.js";
-import { createErrorId, createLogger, formatError, recordErrorOnSpan } from "#internal/logging.js";
-import { formatLanguageModelGatewayId } from "#internal/runtime-model.js";
-import { contextStorage } from "#context/container.js";
-import { toErrorMessage } from "#shared/errors.js";
-import { createCompactionCompletedEvent, createCompactionRequestedEvent, createInputRequestedEvent, } from "#protocol/message.js";
-import { ASK_QUESTION_TOOL_NAME } from "#runtime/framework-tools/ask-question.js";
-import { ConnectionRegistryKey, DiscoveredConnectionToolsKey, } from "#runtime/framework-tools/connection-search.js";
-import { resolveConnectionToolsFromState } from "#runtime/framework-tools/connection-tools.js";
-import { WEB_SEARCH_TOOL_DEFINITION } from "#runtime/framework-tools/web-search.js";
-import { hydrateSandboxAttachments, stageAttachmentsToSandbox, } from "#harness/attachment-staging.js";
-import { compactMessages, getInputTokenCount, resolveCompactionModel, shouldCompact, } from "#harness/compaction.js";
-import { advanceStep, emitFailedStep, emitRecoverableFailedTurn, emitStreamContent, emitTurnEpilogue, emitTurnPreamble, getHarnessEmissionState, setHarnessEmissionState, } from "#harness/emission.js";
-import { extractQuestionInputRequests, extractToolApprovalInputRequests, } from "#harness/input-extraction.js";
-import { consumeDeferredStepInput, getApprovedTools, hasDeferredStepInput, hasStepInput, resolvePendingInput, setPendingInputBatch, } from "#harness/input-requests.js";
-import { getInstrumentationConfig } from "#harness/instrumentation-config.js";
-import { resolveAssistantStepText } from "#harness/messages.js";
-import { classifyModelCallError, extractModelCallErrorDetails, extractUnsupportedProviderToolTypes, summarizeKnownModelCallConfigError, summarizeKnownModelCallRequestError, } from "#harness/model-call-error.js";
-import { ensureOtelIntegration } from "#harness/otel-integration.js";
-import { applyLastToolCacheBreakpoint, detectPromptCachePath, getAnthropicCacheMarker, } from "#harness/prompt-cache.js";
-import { resolveFrameworkToolFromUpstreamType, resolveGatewayPinForWebSearchBackend, resolveWebSearchBackend, } from "#harness/provider-tools.js";
-import { createRuntimeActionRequestFromToolCall, resolvePendingRuntimeActions, setPendingRuntimeActionBatch, } from "#harness/runtime-actions.js";
-import { buildStepHooks, emitStepActions, isInvalidToolCall, } from "#harness/step-hooks.js";
-import { pruneToolResults } from "#harness/tool-result-pruning.js";
-import { buildToolSetWithProviderTools } from "#harness/tools.js";
-/**
- * Creates a tool-loop harness step function backed by AI SDK `ToolLoopAgent`.
- */
-/**
- * Builds the `telemetry` value for the AI SDK from authored settings.
- *
- * Custom metadata (authored `InstrumentationDefinition.metadata` plus
- * ash-specific identifiers such as `ash.session.id`) is flowed through
- * {@link buildTelemetryRuntimeContext} because AI SDK v7 surfaces
- * per-call attributes via `runtimeContext`, not a dedicated metadata
- * field on `TelemetryOptions`.
- */
-const environment = process.env.NODE_ENV ?? "unknown";
-const ashVersion = resolveInstalledPackageInfo().version;
-const log = createLogger("harness.tool-loop");
-/**
- * Max attempts (1 original + N retries) for transient model-call
- * failures before the harness gives up and falls back to the
- * recoverable/terminal emission path. Kept small on purpose — every
- * attempt costs a round-trip plus prompt tokens, and the dominant
- * use case (429 / 502) clears quickly or not at all.
- */
-const MODEL_CALL_MAX_ATTEMPTS = 3;
-/**
- * Base delay (ms) between model-call retries. Doubled each attempt,
- * plus a small random jitter to avoid thundering-herd behavior when
- * a provider incident clears.
- */
-const MODEL_CALL_RETRY_BASE_DELAY_MS = 500;
-function enrichTelemetry(authored, agentName) {
-    if (authored === undefined) {
-        return undefined;
-    }
-    return {
-        functionId: authored.functionId ?? agentName,
-        isEnabled: true,
-        recordInputs: authored.recordInputs ?? true,
-        recordOutputs: authored.recordOutputs ?? true,
-    };
-}
-/**
- * Builds the `runtimeContext` passed into AI SDK calls so that
- * ash-specific identifiers (version, environment, session id,
- * continuation token) and any authored instrumentation metadata
- * are attached to AI SDK spans as `ai.settings.context.*` attributes.
- */
-function buildTelemetryRuntimeContext(authored, session) {
-    if (authored === undefined) {
-        return undefined;
-    }
-    return {
-        ...authored.metadata,
-        "ash.continuation_token": session.continuationToken,
-        "ash.environment": environment,
-        "ash.session.id": session.sessionId,
-        "ash.version": ashVersion,
-    };
-}
-/**
- * Resolves the gateway provider slug to pin via
- * `providerOptions.gateway.only` for one harness step, or `undefined`
- * when no pin is needed.
- *
- * A pin is added when all of:
- * 1. The model is gateway-routed (the `gateway-auto` cache path —
- *    matches the existing `gateway.caching` hint condition).
- * 2. The effective toolset includes a framework provider tool whose
- *    backend pins to one provider (e.g. `web_search` on Anthropic).
- *
- * The author keeps the final say via `providerOptions.gateway.only` or
- * `.order` on their model reference — those overrides flow through
- * {@link mergeGatewayProviderPin} which is a no-op when either field is
- * already set.
- */
-function resolveGatewayPinForStep(input) {
-    if (input.cachePath.kind !== "gateway-auto") {
-        return undefined;
-    }
-    if (input.tools[WEB_SEARCH_TOOL_DEFINITION.name] === undefined) {
-        return undefined;
-    }
-    const backend = resolveWebSearchBackend(input.modelReference);
-    if (backend === null) {
-        return undefined;
-    }
-    const pin = resolveGatewayPinForWebSearchBackend(backend);
-    return pin ?? undefined;
-}
-/**
- * Builds AI Gateway app attribution headers when the model is gateway-routed.
- *
- * Gateway routing is detected by `typeof model === "string"` — the same
- * condition used for the `gateway-auto` cache path. Returns `undefined`
- * for non-gateway models or when no meaningful attribution is available.
- */
-function buildGatewayAttributionHeaders(model, runtimeIdentity) {
-    if (typeof model !== "string") {
-        return undefined;
-    }
-    const title = runtimeIdentity?.agentName ?? runtimeIdentity?.agentId;
-    const deploymentHost = process.env.VERCEL_PROJECT_PRODUCTION_URL || process.env.VERCEL_URL;
-    const referer = deploymentHost ? `https://${deploymentHost}` : undefined;
-    if (!title && !referer) {
-        return undefined;
-    }
-    const headers = {};
-    if (title)
-        headers["x-title"] = title;
-    if (referer)
-        headers["http-referer"] = referer;
-    return headers;
-}
-// ---------------------------------------------------------------------------
-// Turn trace state — survives step boundaries via session.state
-// ---------------------------------------------------------------------------
-const TURN_TRACE_STATE_KEY = "ash.harness.turnTrace";
-function getTurnTraceState(session) {
-    return session.state?.[TURN_TRACE_STATE_KEY];
-}
-function setTurnTraceState(session, spanContext) {
-    const stored = {
-        traceId: spanContext.traceId,
-        spanId: spanContext.spanId,
-        traceFlags: spanContext.traceFlags,
-    };
-    return {
-        ...session,
-        state: {
-            ...session.state,
-            [TURN_TRACE_STATE_KEY]: stored,
-        },
-    };
-}
-/**
- * Resolves the OTel context for the current step.
- *
- * First step of a turn: uses the newly created turn span.
- * Continuation steps: restores the parent span context from session state
- * so AI SDK spans nest under the same trace as the first step.
- */
-function resolveStepOtelContext(tracer, turnSpan, session) {
-    if (turnSpan) {
-        return trace.setSpan(otelContext.active(), turnSpan);
-    }
-    if (tracer) {
-        const stored = getTurnTraceState(session);
-        if (stored) {
-            const parent = trace.wrapSpanContext({
-                traceId: stored.traceId,
-                spanId: stored.spanId,
-                traceFlags: stored.traceFlags,
-            });
-            return trace.setSpan(otelContext.active(), parent);
-        }
-    }
-    return undefined;
-}
-export function createToolLoopHarness(config) {
-    const emit = config.emit;
-    const telemetryConfig = getInstrumentationConfig();
-    if (telemetryConfig !== undefined) {
-        ensureOtelIntegration();
-    }
-    const tracer = telemetryConfig !== undefined ? trace.getTracer("ash") : undefined;
-    const agentName = config.runtimeIdentity?.agentName;
-    async function runStep(initialSession, input) {
-        // --- Turn span lifecycle ------------------------------------------------
-        // First step of a turn: open a new parent span. Continuation steps
-        // restore the parent from session state via resolveStepOtelContext.
-        let turnSpan;
-        if (tracer && hasStepInput(input)) {
-            const functionId = telemetryConfig?.functionId ?? agentName;
-            const attributes = {
-                "ash.version": ashVersion,
-                "ash.environment": environment,
-                "ash.session.id": initialSession.sessionId,
-                "ash.continuation_token": initialSession.continuationToken,
-            };
-            if (functionId) {
-                attributes["ai.telemetry.functionId"] = functionId;
-            }
-            turnSpan = tracer.startSpan("ai.ash.turn", { attributes });
-        }
-        // Run the step body inside the turn span's (or restored parent's)
-        // OTel context so AI SDK spans nest as children.
-        const parentContext = resolveStepOtelContext(tracer, turnSpan, initialSession);
-        const executeStep = () => executeStepBody(initialSession, input, turnSpan);
-        try {
-            if (parentContext) {
-                return await otelContext.with(parentContext, executeStep);
-            }
-            return await executeStep();
-        }
-        finally {
-            turnSpan?.end();
-        }
-    }
-    async function executeStepBody(initialSession, input, turnSpan) {
-        let session = initialSession;
-        // Store the turn span context on the session so continuation steps
-        // can restore the parent trace across step boundaries.
-        if (turnSpan) {
-            session = setTurnTraceState(session, turnSpan.spanContext());
-        }
-        let emissionState = getHarnessEmissionState(session);
-        // Resolve deferred input, runtime actions, then HITL input; each stage
-        // may park when its resume payload has not arrived.
-        const stepInput = consumeDeferredStepInput({ input, session });
-        session = stepInput.session;
-        const resolvedRuntimeActions = await resolvePendingRuntimeActions({
-            emit,
-            session,
-            stepInput: stepInput.input,
-        });
-        if (resolvedRuntimeActions.outcome === "unresolved") {
-            return { next: null, session: resolvedRuntimeActions.session };
-        }
-        session = resolvedRuntimeActions.session;
-        const pending = resolvePendingInput({
-            history: resolvedRuntimeActions.messages,
-            resolveApprovalKey: resolveApprovalKeyFromTools(config.tools),
-            session,
-            stepInput: stepInput.input,
-        });
-        if (pending.outcome === "unresolved") {
-            return { next: null, session: pending.session };
-        }
-        // --- Turn preamble ------------------------------------------------------
-        if (emit && hasStepInput(input)) {
-            emissionState = await emitTurnPreamble(emit, input ?? {}, emissionState, config.runtimeIdentity);
-            session = setHarnessEmissionState(session, emissionState);
-            if (turnSpan) {
-                turnSpan.setAttribute("ash.turn.id", emissionState.turnId);
-            }
-        }
-        session = pending.session;
-        let messages = pending.messages;
-        if (stepInput.input?.message !== undefined && !pending.deferredMessage) {
-            // Staging writes FilePart bytes into the sandbox and replaces
-            // each part's `data` with a compact `ash-sandbox:` URL. The
-            // `messages` array — and everything that flows into
-            // `session.history` from it — therefore never carries raw
-            // attachment bytes across step boundaries.
-            const content = await stageAttachmentsToSandbox(stepInput.input.message);
-            messages.push({ content, role: "user" });
-        }
-        // --- Model + tools ------------------------------------------------------
-        const model = await config.resolveModel(session.agent.modelReference);
-        const cachePath = detectPromptCachePath(model);
-        const marker = cachePath.kind === "anthropic-direct" ? getAnthropicCacheMarker() : undefined;
-        // --- Compaction ---------------------------------------------------------
-        //
-        // Runs before `agent.stream()` so the compacted messages flow through
-        // `messages` (which the harness uses to rebuild session history).
-        const attributionHeaders = buildGatewayAttributionHeaders(model, config.runtimeIdentity);
-        ({ messages, session } = await maybeCompact({
-            emit,
-            emissionState,
-            headers: attributionHeaders,
-            messages,
-            model,
-            onCompaction: config.onCompaction,
-            resolveModel: config.resolveModel,
-            session,
-            telemetry: enrichTelemetry(telemetryConfig, agentName) ?? undefined,
-        }));
-        const approvedTools = getApprovedTools(session);
-        // Inject connection tools discovered by a prior `connection_search`.
-        // Direct harness unit tests may run without an ambient context.
-        const ctx = contextStorage.getStore();
-        const registry = ctx?.get(ConnectionRegistryKey);
-        const discovered = ctx?.get(DiscoveredConnectionToolsKey);
-        // --- Execute via ToolLoopAgent ------------------------------------------
-        /*
-         * The `onError` override suppresses the AI SDK's default
-         * `console.error(error)` handler inside `streamText`. Errors are
-         * handled by the harness catch block and emitted as stream events.
-         */
-        // Hydrate `ash-sandbox:` ref FileParts into inline bytes for the
-        // model call only. The result is transient — `messages` itself
-        // remains ref-only so it can flow into `session.history` without
-        // bloating every future step boundary.
-        const hydratedMessages = await hydrateSandboxAttachments(messages);
-        const ephemeralContext = stepInput.input?.modelContext;
-        // AI SDK rejects role:"system" in `messages` — route durable history
-        // and ephemeral context system entries to `instructions` instead.
-        const systemMessages = [];
-        const nonSystemMessages = [];
-        for (const entry of hydratedMessages) {
-            if (entry.role === "system") {
-                systemMessages.push(entry);
-            }
-            else {
-                nonSystemMessages.push(entry);
-            }
-        }
-        if (ephemeralContext !== undefined) {
-            for (const entry of ephemeralContext) {
-                if (entry.role === "system") {
-                    systemMessages.push(entry);
-                }
-                else {
-                    nonSystemMessages.push(entry);
-                }
-            }
-        }
-        const modelMessages = nonSystemMessages;
-        /**
-         * Assembles the effective toolset, instructions, and ToolLoopAgent
-         * for one attempt of this step, then runs the model call.
-         *
-         * Called twice in the recovery path: once for the original attempt
-         * with full tools, and once after the gateway rejects a
-         * provider-specific tool — the retry passes `disabledProviderTools`
-         * to drop the offending tool and `extraSystemNote` to tell the
-         * model why a capability was removed.
-         */
-        const runOneModelCall = async (opts) => {
-            const tools = await buildToolSetWithProviderTools({
-                approvedTools,
-                capabilities: config.capabilities,
-                disabledProviderTools: opts.disabledProviderTools,
-                modelReference: session.agent.modelReference,
-                tools: config.tools,
-            });
-            if (registry !== undefined && discovered !== undefined) {
-                const connectionTools = await resolveConnectionToolsFromState(registry, discovered, {
-                    approvedTools,
-                    existingToolNames: new Set(Object.keys(tools)),
-                });
-                Object.assign(tools, connectionTools);
-            }
-            const effectiveTools = marker ? applyLastToolCacheBreakpoint(tools, marker) : tools;
-            // Pin gateway routing to the provider that owns any
-            // provider-specific tool in this step's toolset. Converts a
-            // transient primary outage into a retryable 503 instead of
-            // routing to an incompatible fallback provider. Skipped on the
-            // recovery retry because the offending tool was dropped — any
-            // provider can serve the request now.
-            const gatewayPinProvider = resolveGatewayPinForStep({
-                cachePath,
-                modelReference: session.agent.modelReference,
-                tools: effectiveTools,
-            });
-            // Build instructions, optionally prepending the recovery
-            // system note so the model sees one explicit signal that a
-            // capability was removed for this attempt.
-            const extraSystemEntry = opts.extraSystemNote
-                ? [{ role: "system", content: opts.extraSystemNote }]
-                : [];
-            const baseSystemEntry = session.agent.system
-                ? [{ role: "system", content: session.agent.system }]
-                : [];
-            const instructions = systemMessages.length > 0 || extraSystemEntry.length > 0
-                ? [...extraSystemEntry, ...baseSystemEntry, ...systemMessages]
-                : session.agent.system || undefined;
-            const hooks = buildStepHooks({
-                cachePath,
-                emit,
-                emissionState,
-                emitStepStarted: opts.suppressStepStartedEmission !== true,
-                gatewayPinProvider,
-                marker,
-                session,
-            });
-            const agentSettings = {
-                headers: attributionHeaders,
-                instructions,
-                model,
-                onError() { },
-                onStepFinish: hooks.onStepFinish,
-                prepareStep: hooks.prepareStep,
-                runtimeContext: buildTelemetryRuntimeContext(telemetryConfig, session),
-                stopWhen: isStepCount(1),
-                telemetry: enrichTelemetry(telemetryConfig, agentName),
-                tools: effectiveTools,
-            };
-            const agent = new ToolLoopAgent(agentSettings);
-            const executeModelCall = async () => {
-                if (emit) {
-                    const streamResult = await agent.stream({ messages: modelMessages });
-                    const { inlineActionResultCallIds, inlineToolResultParts } = await emitStreamContent(emit, emissionState, streamResult.fullStream);
-                    const stepResult = await hooks.stepResult;
-                    await emitStepActions(emit, emissionState, stepResult, {
-                        excludedActionToolNames: new Set([ASK_QUESTION_TOOL_NAME]),
-                        inlineActionResultCallIds,
-                        tools: config.tools,
-                    });
-                    if (inlineToolResultParts.length > 0) {
-                        /*
-                         * AI SDK `StepResult` is a class whose `content`,
-                         * `toolCalls`, `toolResults`, `text` are prototype getters.
-                         * Each field is read explicitly here rather than via spread
-                         * so the returned plain object carries the values — spread
-                         * would copy only own enumerable properties and the
-                         * downstream `extractQuestionInputRequests` would crash on
-                         * `toolCalls === undefined`.
-                         */
-                        return {
-                            content: stepResult.content,
-                            finishReason: stepResult.finishReason,
-                            response: {
-                                ...stepResult.response,
-                                messages: [
-                                    { role: "tool", content: [...inlineToolResultParts] },
-                                    ...stepResult.response.messages,
-                                ],
-                            },
-                            text: stepResult.text,
-                            toolCalls: stepResult.toolCalls,
-                            toolResults: stepResult.toolResults,
-                            usage: stepResult.usage,
-                        };
-                    }
-                    return stepResult;
-                }
-                await agent.generate({ messages: modelMessages });
-                return await hooks.stepResult;
-            };
-            return runModelCallWithRetries(executeModelCall, {
-                sessionId: session.sessionId,
-                turnId: emissionState.turnId,
-            });
-        };
-        let result;
-        try {
-            result = await runOneModelCall({});
-        }
-        catch (error) {
-            // First, try to recover by dropping any provider-specific tool
-            // that the AI Gateway's fallback provider rejected. This converts
-            // the otherwise-terminal failure into one extra model call with a
-            // degraded toolset — the agent's turn proceeds without the
-            // capability the chosen provider could not serve.
-            const recoveryResult = await attemptUnsupportedProviderToolRecovery({
-                error,
-                runOneModelCall,
-                sessionId: session.sessionId,
-                turnId: emissionState.turnId,
-            });
-            if (recoveryResult.outcome === "recovered") {
-                result = recoveryResult.result;
-            }
-            else {
-                // Surface the full cause chain + upstream responseBody to OTel
-                // via the turn span. The AI SDK's automatic
-                // `span.recordException(err)` on its own `ai.streamText` span
-                // only captures `error.stack` and does not traverse `cause`,
-                // so the gateway-wrapped upstream 4xx body would otherwise be
-                // invisible to OTel providers.
-                const finalError = recoveryResult.error;
-                if (turnSpan) {
-                    recordErrorOnSpan(turnSpan, finalError);
-                }
-                if (!emit) {
-                    // Internal harness callers without an emit fn (tests, task-only
-                    // code paths) get the raw throw. Only runtime-connected harness
-                    // calls go through the structured failure path below.
-                    throw finalError;
-                }
-                const classification = classifyModelCallError(finalError);
-                const errorId = createErrorId();
-                const configSummary = classification === "terminal" ? summarizeKnownModelCallConfigError(finalError) : null;
-                const requestSummary = configSummary === null ? summarizeKnownModelCallRequestError(finalError) : null;
-                const errorMessage = configSummary?.message ?? requestSummary?.message ?? toErrorMessage(finalError);
-                const modelCallDetails = extractModelCallErrorDetails(finalError);
-                const details = buildModelCallFailureDetails({
-                    configSummary,
-                    error: finalError,
-                    errorId,
-                    modelCallDetails,
-                    requestSummary,
-                });
-                const modelCallLogFields = buildModelCallFailureLogFields({
-                    error: finalError,
-                    errorId,
-                    modelCallDetails,
-                    requestSummary,
-                    sessionId: session.sessionId,
-                    turnId: emissionState.turnId,
-                });
-                if (classification === "terminal") {
-                    if (configSummary !== null) {
-                        // Recognized configuration failure: log a concise single line
-                        // and skip the structured SDK dump so the user sees an
-                        // actionable hint instead of a wall of inspector output.
-                        log.error(`${configSummary.name}: ${configSummary.message}`, {
-                            errorId,
-                            sessionId: session.sessionId,
-                            turnId: emissionState.turnId,
-                        });
-                    }
-                    else {
-                        log.error(requestSummary?.message ?? "model call failed terminally", modelCallLogFields);
-                    }
-                    await emitFailedStep(emit, emissionState, {
-                        code: "MODEL_CALL_FAILED",
-                        details,
-                        message: errorMessage,
-                        sessionId: session.sessionId,
-                    });
-                    return {
-                        next: { done: true, output: "" },
-                        session,
-                    };
-                }
-                log.error(requestSummary?.message ?? "model call failed — parking session for retry by the user", modelCallLogFields);
-                emissionState = await emitRecoverableFailedTurn(emit, emissionState, {
-                    code: "MODEL_CALL_FAILED",
-                    details,
-                    message: errorMessage,
-                });
-                const parkedSession = setHarnessEmissionState(session, emissionState);
-                return { next: null, session: parkedSession };
-            }
-        }
-        // --- Handle result ------------------------------------------------------
-        return handleStepResult({
-            config,
-            emit,
-            emissionState,
-            promptMessages: messages,
-            result,
-            runStep,
-            session,
-        });
-    }
-    return runStep;
-}
-// ---------------------------------------------------------------------------
-// Model-call failure projection
-// ---------------------------------------------------------------------------
-/**
- * Projects a model-call failure into the `step.failed` / `turn.failed`
- * `details` payload. Three mutually exclusive branches:
- *
- * 1. Config summary (known terminal: missing key, gateway auth)  → friendly
- *    `name` + `message`, no SDK inspector dump.
- * 2. Request summary (ambiguous gateway 4xx that we recover from) → raw
- *    error `message`, friendly `name`, no inspector dump.
- * 3. Fallback → full {@link formatError} projection (cause chain via
- *    `util.inspect`) so unrecognized failures still carry the upstream
- *    stack to log aggregators.
- *
- * All branches merge {@link extractModelCallErrorDetails} on top so the
- * compact gateway diagnostics (`statusCode`, `upstreamMessage`,
- * `responseBodySnippet`, ...) always show up next to the message.
- */
-function buildModelCallFailureDetails(input) {
-    const { configSummary, error, errorId, modelCallDetails, requestSummary } = input;
-    if (configSummary !== null) {
-        return {
-            errorId,
-            message: configSummary.message,
-            name: configSummary.name,
-            ...modelCallDetails,
-        };
-    }
-    if (requestSummary !== null) {
-        return {
-            errorId,
-            message: toErrorMessage(error),
-            name: requestSummary.name,
-            ...modelCallDetails,
-        };
-    }
-    return { ...formatError(error, errorId), ...modelCallDetails };
-}
-/**
- * Builds the structured log fields for a model-call failure. When we
- * recognized the failure as an ambiguous gateway request rejection, attach
- * the compact `details` payload and *omit* the raw `error` so the logger's
- * `util.inspect` of the cause chain (which would render `[object Object]`
- * for upstream `APICallError` shapes) is bypassed. Otherwise fall back to
- * the raw error so unrecognized failures keep their full stack in logs.
- */
-function buildModelCallFailureLogFields(input) {
-    const base = {
-        errorId: input.errorId,
-        sessionId: input.sessionId,
-        turnId: input.turnId,
-    };
-    if (input.requestSummary !== null) {
-        return { ...base, details: input.modelCallDetails };
-    }
-    return { ...base, error: input.error };
-}
-/**
- * Inspects a model-call failure for the "tool type 'X' is not supported"
- * provider-attempt rejection that AI Gateway returns when a fallback
- * provider cannot serve a provider-specific tool. On a match, retries the
- * step once with the offending tool dropped and a one-shot system note
- * telling the model which capability has been removed.
- *
- * Returns `recovered` when the retry succeeded so the caller can hand
- * the result off to the usual post-step handler. Returns `failed`
- * (with the original error, or the retry's error if the retry also
- * threw) otherwise so the caller's existing terminal/recoverable
- * cascade still runs.
- *
- * Recovery is intentionally scoped to known provider tools — entries in
- * {@link UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME} — so an unrelated
- * upstream rejection cannot accidentally drop a user-authored tool.
- */
-async function attemptUnsupportedProviderToolRecovery(input) {
-    const unsupportedTypes = extractUnsupportedProviderToolTypes(input.error);
-    if (unsupportedTypes.length === 0) {
-        return { outcome: "failed", error: input.error };
-    }
-    const toolsToDisable = [];
-    for (const type of unsupportedTypes) {
-        const frameworkName = resolveFrameworkToolFromUpstreamType(type);
-        if (frameworkName !== null && !toolsToDisable.includes(frameworkName)) {
-            toolsToDisable.push(frameworkName);
-        }
-    }
-    if (toolsToDisable.length === 0) {
-        return { outcome: "failed", error: input.error };
-    }
-    log.warn("disabling unsupported provider tool(s); retrying step once", {
-        disabled: toolsToDisable,
-        sessionId: input.sessionId,
-        turnId: input.turnId,
-        upstreamTypes: unsupportedTypes,
-    });
-    try {
-        const result = await input.runOneModelCall({
-            disabledProviderTools: new Set(toolsToDisable),
-            extraSystemNote: buildDisabledToolNote(toolsToDisable),
-            suppressStepStartedEmission: true,
-        });
-        return { outcome: "recovered", result };
-    }
-    catch (retryError) {
-        return { outcome: "failed", error: retryError };
-    }
-}
-/**
- * Builds the one-shot system note prepended to the recovery retry's
- * instructions so the model has explicit context for why a capability
- * disappeared mid-turn.
- */
-function buildDisabledToolNote(toolNames) {
-    const list = toolNames.join(", ");
-    const noun = toolNames.length === 1 ? "tool is" : "tools are";
-    return (`The following ${noun} not available with the current model and ` +
-        `has been removed: ${list}. Proceed using the remaining tools or your ` +
-        `training knowledge.`);
-}
-// ---------------------------------------------------------------------------
-// Post-step result handling
-// ---------------------------------------------------------------------------
-/**
- * Processes the step result: extracts input requests, decides whether to
- * park, continue the tool loop, or terminate.
- */
-async function handleStepResult(input) {
-    const { config, emit, promptMessages, result, runStep } = input;
-    let { emissionState, session } = input;
-    const responseMessages = result.response.messages;
-    const stepOutput = resolveAssistantStepText(responseMessages, result.text);
-    const approvalRequests = extractToolApprovalInputRequests({ content: result.content ?? [] });
-    const approvalRequestCallIds = new Set(approvalRequests.map((request) => request.action.callId));
-    const questionRequests = extractQuestionInputRequests({
-        toolCalls: result.toolCalls,
-        excludedCallIds: approvalRequestCallIds,
-    });
-    const inputRequests = [...approvalRequests, ...questionRequests];
-    const baseSession = {
-        ...session,
-        compaction: createNextCompactionConfig(session.compaction, promptMessages, result),
-    };
-    const pendingRuntimeActions = (result.toolCalls ?? [])
-        .filter((toolCall) => !isInvalidToolCall(toolCall))
-        .filter((toolCall) => config.tools.get(toolCall.toolName)?.runtimeAction !== undefined)
-        .map((toolCall) => createRuntimeActionRequestFromToolCall({
-        toolCall,
-        tools: config.tools,
-    }));
-    if (pendingRuntimeActions.length > 0) {
-        return {
-            next: null,
-            session: setPendingRuntimeActionBatch({
-                actions: pendingRuntimeActions,
-                event: {
-                    sequence: emissionState.sequence,
-                    stepIndex: emissionState.stepIndex,
-                    turnId: emissionState.turnId,
-                },
-                responseMessages,
-                session: { ...baseSession, history: [...promptMessages] },
-            }),
-        };
-    }
-    // --- Park on input requests -----------------------------------------------
-    if (inputRequests.length > 0) {
-        let parkedSession = setPendingInputBatch({
-            requests: inputRequests,
-            responseMessages,
-            session: { ...baseSession, history: [...promptMessages] },
-        });
-        if (emit) {
-            await emit(createInputRequestedEvent({
-                requests: inputRequests,
-                sequence: emissionState.sequence,
-                stepIndex: emissionState.stepIndex,
-                turnId: emissionState.turnId,
-            }));
-            if (config.mode === "conversation") {
-                emissionState = await emitTurnEpilogue(emit, emissionState, config.mode);
-                parkedSession = setHarnessEmissionState(parkedSession, emissionState);
-            }
-        }
-        return { next: null, session: parkedSession };
-    }
-    // --- Continue or terminate ------------------------------------------------
-    const prunedHistory = pruneToolResults(promptMessages, config.retentionPolicies);
-    const historyWasPruned = prunedHistory !== promptMessages;
-    // When pruning rewrites messages that the model already counted, the
-    // exact input-token snapshot recorded by createNextCompactionConfig
-    // becomes stale. Clear it so the next step falls back to the
-    // estimation heuristic instead of overestimating and compacting early.
-    let compaction = baseSession.compaction;
-    if (historyWasPruned && compaction.lastKnownInputTokens !== undefined) {
-        compaction = {
-            recentWindowSize: compaction.recentWindowSize,
-            threshold: compaction.threshold,
-        };
-    }
-    const updatedHistory = [...prunedHistory, ...responseMessages];
-    let nextSession = { ...baseSession, compaction, history: updatedHistory };
-    const continueLoop = responseMessages.at(-1)?.role === "tool" || hasDeferredStepInput(nextSession);
-    if (emit) {
-        if (!continueLoop) {
-            emissionState = await emitTurnEpilogue(emit, emissionState, config.mode);
-        }
-        else {
-            emissionState = advanceStep(emissionState);
-        }
-        nextSession = setHarnessEmissionState(nextSession, emissionState);
-    }
-    if (continueLoop) {
-        return { next: runStep, session: nextSession };
-    }
-    return {
-        next: config.mode === "task" ? { done: true, output: stepOutput ?? "" } : null,
-        session: nextSession,
-    };
-}
-function createNextCompactionConfig(current, promptMessages, result) {
-    const next = {
-        recentWindowSize: current.recentWindowSize,
-        threshold: current.threshold,
-    };
-    if (result.usage?.inputTokens !== undefined) {
-        next.lastKnownInputTokens = result.usage.inputTokens;
-        next.lastKnownPromptMessageCount = promptMessages.length;
-    }
-    return next;
-}
-/**
- * Runs the compaction pipeline once if the session's input-token estimate
- * is over the configured threshold. Mutates neither input; returns the new
- * messages array and (possibly updated) session.
- *
- * Kept in the tool-loop (rather than the AI SDK's `prepareStep` hook) so
- * the compacted messages flow through the same `messages` variable the
- * harness uses to rebuild `session.history` after the step.
- */
-async function maybeCompact(input) {
-    const { emit, emissionState } = input;
-    let messages = input.messages;
-    let session = input.session;
-    if (!shouldCompact(messages, session.compaction)) {
-        return { messages, session };
-    }
-    const compaction = await resolveCompactionModel({
-        compactionModelReference: session.agent.compactionModelReference,
-        model: input.model,
-        modelReference: session.agent.modelReference,
-        resolveModel: input.resolveModel,
-    });
-    if (emit) {
-        await emit(createCompactionRequestedEvent({
-            modelId: formatLanguageModelGatewayId(compaction.model),
-            sequence: emissionState.sequence,
-            sessionId: session.sessionId,
-            turnId: emissionState.turnId,
-            usageInputTokens: getInputTokenCount(messages, session.compaction),
-        }));
-    }
-    messages = await compactMessages(messages, compaction.model, session.compaction, compaction.providerOptions, input.telemetry, input.headers);
-    if (input.onCompaction) {
-        const compacted = await input.onCompaction(session);
-        session = compacted.session;
-        for (const msg of compacted.messages) {
-            messages.push(msg);
-        }
-    }
-    if (emit) {
-        await emit(createCompactionCompletedEvent({
-            modelId: formatLanguageModelGatewayId(compaction.model),
-            sequence: emissionState.sequence,
-            sessionId: session.sessionId,
-            turnId: emissionState.turnId,
-        }));
-    }
-    return { messages, session };
-}
-/**
- * Creates an approval-key resolver from the tool map. The resolver computes
- * compound keys at recording time instead of pre-computing and persisting
- * them on the pending batch.
- */
-function resolveApprovalKeyFromTools(tools) {
-    return (request) => {
-        const toolDef = tools.get(request.action.toolName);
-        if (toolDef?.approvalKey === undefined) {
-            return undefined;
-        }
-        return toolDef.approvalKey(request.action.input);
-    };
-}
-/**
- * Retries `fn` with exponential backoff while the thrown error is
- * classified as `"retry"`. Rethrows the last error once attempts are
- * exhausted or the error is classified as something other than
- * transient.
- */
-async function runModelCallWithRetries(fn, diag) {
-    for (let attempt = 1;; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            if (attempt === MODEL_CALL_MAX_ATTEMPTS || classifyModelCallError(error) !== "retry") {
-                throw error;
-            }
-            const delayMs = MODEL_CALL_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1) + Math.floor(Math.random() * 250);
-            log.warn("model call failed transiently — retrying", {
-                attempt,
-                delayMs,
-                sessionId: diag.sessionId,
-                turnId: diag.turnId,
-                error,
-            });
-            await new Promise((resolve) => setTimeout(resolve, delayMs));
-        }
-    }
-}
+import{createErrorId,createLogger,formatError,recordErrorOnSpan}from"#internal/logging.js";import{toErrorMessage}from"#shared/errors.js";import{createCompactionCompletedEvent,createCompactionRequestedEvent,createInputRequestedEvent}from"#protocol/message.js";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{formatLanguageModelGatewayId}from"#internal/runtime-model.js";import{contextStorage}from"#context/container.js";import{context,trace}from"#compiled/@opentelemetry/api/index.js";import{ConnectionRegistryKey,DiscoveredConnectionToolsKey}from"#runtime/framework-tools/connection-search.js";import{ToolLoopAgent,isStepCount}from"ai";import{advanceStep,emitFailedStep,emitRecoverableFailedTurn,emitStreamContent,emitTurnEpilogue,emitTurnPreamble,getHarnessEmissionState,setHarnessEmissionState}from"#harness/emission.js";import{consumeDeferredStepInput,getApprovedTools,hasDeferredStepInput,hasStepInput,resolvePendingInput,setPendingInputBatch}from"#harness/input-requests.js";import{createRuntimeActionRequestFromToolCall,resolvePendingRuntimeActions,setPendingRuntimeActionBatch}from"#harness/runtime-actions.js";import{resolveAssistantStepText}from"#harness/messages.js";import{ASK_QUESTION_TOOL_NAME}from"#runtime/framework-tools/ask-question.js";import{WEB_SEARCH_TOOL_DEFINITION}from"#runtime/framework-tools/web-search.js";import{extractQuestionInputRequests,extractToolApprovalInputRequests}from"#harness/input-extraction.js";import{applyLastToolCacheBreakpoint,detectPromptCachePath,getAnthropicCacheMarker}from"#harness/prompt-cache.js";import{resolveFrameworkToolFromUpstreamType,resolveGatewayPinForWebSearchBackend,resolveWebSearchBackend}from"#harness/provider-tools.js";import{resolveConnectionToolsFromState}from"#runtime/framework-tools/connection-tools.js";import{hydrateSandboxAttachments,stageAttachmentsToSandbox}from"#harness/attachment-staging.js";import{compactMessages,getInputTokenCount,resolveCompactionModel,shouldCompact}from"#harness/compaction.js";import{getInstrumentationConfig}from"#harness/instrumentation-config.js";import{classifyModelCallError,extractModelCallErrorDetails,extractUnsupportedProviderToolTypes,summarizeKnownModelCallConfigError,summarizeKnownModelCallRequestError}from"#harness/model-call-error.js";import{ensureOtelIntegration}from"#harness/otel-integration.js";import{buildStepHooks,emitStepActions,isInvalidToolCall}from"#harness/step-hooks.js";import{pruneToolResults}from"#harness/tool-result-pruning.js";import{buildToolSetWithProviderTools}from"#harness/tools.js";var environment=process.env.NODE_ENV??`unknown`,ashVersion=resolveInstalledPackageInfo().version,log=createLogger(`harness.tool-loop`),MODEL_CALL_MAX_ATTEMPTS=3,MODEL_CALL_RETRY_BASE_DELAY_MS=500;function enrichTelemetry(e,t){if(e!==void 0)return{functionId:e.functionId??t,isEnabled:!0,recordInputs:e.recordInputs??!0,recordOutputs:e.recordOutputs??!0}}function buildTelemetryRuntimeContext(e,t){if(e!==void 0)return{...e.metadata,"ash.continuation_token":t.continuationToken,"ash.environment":environment,"ash.session.id":t.sessionId,"ash.version":ashVersion}}function resolveGatewayPinForStep(e){if(e.cachePath.kind!==`gateway-auto`||e.tools[WEB_SEARCH_TOOL_DEFINITION.name]===void 0)return;let t=resolveWebSearchBackend(e.modelReference);return t===null?void 0:resolveGatewayPinForWebSearchBackend(t)??void 0}function buildGatewayAttributionHeaders(e,t){if(typeof e!=`string`)return;let n=t?.agentName??t?.agentId,r=process.env.VERCEL_PROJECT_PRODUCTION_URL||process.env.VERCEL_URL,i=r?`https://${r}`:void 0;if(!n&&!i)return;let a={};return n&&(a[`x-title`]=n),i&&(a[`http-referer`]=i),a}var TURN_TRACE_STATE_KEY=`ash.harness.turnTrace`;function getTurnTraceState(e){return e.state?.[TURN_TRACE_STATE_KEY]}function setTurnTraceState(e,t){let n={traceId:t.traceId,spanId:t.spanId,traceFlags:t.traceFlags};return{...e,state:{...e.state,[TURN_TRACE_STATE_KEY]:n}}}function resolveStepOtelContext(e,t,n){if(t)return trace.setSpan(context.active(),t);if(e){let e=getTurnTraceState(n);if(e){let t=trace.wrapSpanContext({traceId:e.traceId,spanId:e.spanId,traceFlags:e.traceFlags});return trace.setSpan(context.active(),t)}}}function createToolLoopHarness(t){let n=t.emit,a=getInstrumentationConfig();a!==void 0&&ensureOtelIntegration();let o=a===void 0?void 0:trace.getTracer(`ash`),s=t.runtimeIdentity?.agentName;async function runStep(e,t){let n;if(o&&hasStepInput(t)){let t=a?.functionId??s,r={"ash.version":ashVersion,"ash.environment":environment,"ash.session.id":e.sessionId,"ash.continuation_token":e.continuationToken};t&&(r[`ai.telemetry.functionId`]=t),n=o.startSpan(`ai.ash.turn`,{attributes:r})}let r=resolveStepOtelContext(o,n,e),executeStep=()=>executeStepBody(e,t,n);try{return r?await context.with(r,executeStep):await executeStep()}finally{n?.end()}}async function executeStepBody(o,c,l){let d=o;l&&(d=setTurnTraceState(d,l.spanContext()));let f=getHarnessEmissionState(d),_=consumeDeferredStepInput({input:c,session:d});d=_.session;let x=await resolvePendingRuntimeActions({emit:n,session:d,stepInput:_.input});if(x.outcome===`unresolved`)return{next:null,session:x.session};d=x.session;let T=resolvePendingInput({history:x.messages,resolveApprovalKey:resolveApprovalKeyFromTools(t.tools),session:d,stepInput:_.input});if(T.outcome===`unresolved`)return{next:null,session:T.session};n&&hasStepInput(c)&&(f=await emitTurnPreamble(n,c??{},f,t.runtimeIdentity),d=setHarnessEmissionState(d,f),l&&l.setAttribute(`ash.turn.id`,f.turnId)),d=T.session;let E=T.messages;if(_.input?.message!==void 0&&!T.deferredMessage){let e=await stageAttachmentsToSandbox(_.input.message);E.push({content:e,role:`user`})}let D=await t.resolveModel(d.agent.modelReference),O=detectPromptCachePath(D),k=O.kind===`anthropic-direct`?getAnthropicCacheMarker():void 0,A=buildGatewayAttributionHeaders(D,t.runtimeIdentity);({messages:E,session:d}=await maybeCompact({emit:n,emissionState:f,headers:A,messages:E,model:D,onCompaction:t.onCompaction,resolveModel:t.resolveModel,session:d,telemetry:enrichTelemetry(a,s)??void 0}));let j=getApprovedTools(d),M=contextStorage.getStore(),N=M?.get(ConnectionRegistryKey),P=M?.get(DiscoveredConnectionToolsKey),F=await hydrateSandboxAttachments(E),I=_.input?.modelContext,L=[],R=[];for(let e of F)e.role===`system`?L.push(e):R.push(e);if(I!==void 0)for(let e of I)e.role===`system`?L.push(e):R.push(e);let z=R,runOneModelCall=async e=>{let r=await buildToolSetWithProviderTools({approvedTools:j,capabilities:t.capabilities,disabledProviderTools:e.disabledProviderTools,modelReference:d.agent.modelReference,tools:t.tools});if(N!==void 0&&P!==void 0){let e=await resolveConnectionToolsFromState(N,P,{approvedTools:j,existingToolNames:new Set(Object.keys(r))});Object.assign(r,e)}let i=k?applyLastToolCacheBreakpoint(r,k):r,o=resolveGatewayPinForStep({cachePath:O,modelReference:d.agent.modelReference,tools:i}),c=e.extraSystemNote?[{role:`system`,content:e.extraSystemNote}]:[],l=d.agent.system?[{role:`system`,content:d.agent.system}]:[],u=L.length>0||c.length>0?[...c,...l,...L]:d.agent.system||void 0,p=buildStepHooks({cachePath:O,emit:n,emissionState:f,emitStepStarted:e.suppressStepStartedEmission!==!0,gatewayPinProvider:o,marker:k,session:d}),m=new ToolLoopAgent({headers:A,instructions:u,model:D,onError(){},onStepFinish:p.onStepFinish,prepareStep:p.prepareStep,runtimeContext:buildTelemetryRuntimeContext(a,d),stopWhen:isStepCount(1),telemetry:enrichTelemetry(a,s),tools:i});return runModelCallWithRetries(async()=>{if(n){let e=await m.stream({messages:z}),{inlineActionResultCallIds:r,inlineToolResultParts:i}=await emitStreamContent(n,f,e.fullStream),a=await p.stepResult;return await emitStepActions(n,f,a,{excludedActionToolNames:new Set([ASK_QUESTION_TOOL_NAME]),inlineActionResultCallIds:r,tools:t.tools}),i.length>0?{content:a.content,finishReason:a.finishReason,response:{...a.response,messages:[{role:`tool`,content:[...i]},...a.response.messages]},text:a.text,toolCalls:a.toolCalls,toolResults:a.toolResults,usage:a.usage}:a}return await m.generate({messages:z}),await p.stepResult},{sessionId:d.sessionId,turnId:f.turnId})},B;try{B=await runOneModelCall({})}catch(t){let a=await attemptUnsupportedProviderToolRecovery({error:t,runOneModelCall,sessionId:d.sessionId,turnId:f.turnId});if(a.outcome===`recovered`)B=a.result;else{let t=a.error;if(l&&recordErrorOnSpan(l,t),!n)throw t;let o=classifyModelCallError(t),s=createErrorId(),c=o===`terminal`?summarizeKnownModelCallConfigError(t):null,u=c===null?summarizeKnownModelCallRequestError(t):null,p=c?.message??u?.message??toErrorMessage(t),m=extractModelCallErrorDetails(t),h=buildModelCallFailureDetails({configSummary:c,error:t,errorId:s,modelCallDetails:m,requestSummary:u}),g=buildModelCallFailureLogFields({error:t,errorId:s,modelCallDetails:m,requestSummary:u,sessionId:d.sessionId,turnId:f.turnId});return o===`terminal`?(c===null?log.error(u?.message??`model call failed terminally`,g):log.error(`${c.name}: ${c.message}`,{errorId:s,sessionId:d.sessionId,turnId:f.turnId}),await emitFailedStep(n,f,{code:`MODEL_CALL_FAILED`,details:h,message:p,sessionId:d.sessionId}),{next:{done:!0,output:``},session:d}):(log.error(u?.message??`model call failed — parking session for retry by the user`,g),f=await emitRecoverableFailedTurn(n,f,{code:`MODEL_CALL_FAILED`,details:h,message:p}),{next:null,session:setHarnessEmissionState(d,f)})}}return handleStepResult({config:t,emit:n,emissionState:f,promptMessages:E,result:B,runStep,session:d})}return runStep}function buildModelCallFailureDetails(e){let{configSummary:t,error:r,errorId:a,modelCallDetails:o,requestSummary:s}=e;return t===null?s===null?{...formatError(r,a),...o}:{errorId:a,message:toErrorMessage(r),name:s.name,...o}:{errorId:a,message:t.message,name:t.name,...o}}function buildModelCallFailureLogFields(e){let t={errorId:e.errorId,sessionId:e.sessionId,turnId:e.turnId};return e.requestSummary===null?{...t,error:e.error}:{...t,details:e.modelCallDetails}}async function attemptUnsupportedProviderToolRecovery(e){let t=extractUnsupportedProviderToolTypes(e.error);if(t.length===0)return{outcome:`failed`,error:e.error};let n=[];for(let e of t){let t=resolveFrameworkToolFromUpstreamType(e);t!==null&&!n.includes(t)&&n.push(t)}if(n.length===0)return{outcome:`failed`,error:e.error};log.warn(`disabling unsupported provider tool(s); retrying step once`,{disabled:n,sessionId:e.sessionId,turnId:e.turnId,upstreamTypes:t});try{return{outcome:`recovered`,result:await e.runOneModelCall({disabledProviderTools:new Set(n),extraSystemNote:buildDisabledToolNote(n),suppressStepStartedEmission:!0})}}catch(e){return{outcome:`failed`,error:e}}}function buildDisabledToolNote(e){let t=e.join(`, `);return`The following ${e.length===1?`tool is`:`tools are`} not available with the current model and has been removed: ${t}. Proceed using the remaining tools or your training knowledge.`}async function handleStepResult(e){let{config:t,emit:n,promptMessages:r,result:i,runStep:a}=e,{emissionState:o,session:c}=e,l=i.response.messages,u=resolveAssistantStepText(l,i.text),d=extractToolApprovalInputRequests({content:i.content??[]}),f=new Set(d.map(e=>e.action.callId)),p=extractQuestionInputRequests({toolCalls:i.toolCalls,excludedCallIds:f}),m=[...d,...p],h={...c,compaction:createNextCompactionConfig(c.compaction,r,i)},g=(i.toolCalls??[]).filter(e=>!isInvalidToolCall(e)).filter(e=>t.tools.get(e.toolName)?.runtimeAction!==void 0).map(e=>createRuntimeActionRequestFromToolCall({toolCall:e,tools:t.tools}));if(g.length>0)return{next:null,session:setPendingRuntimeActionBatch({actions:g,event:{sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId},responseMessages:l,session:{...h,history:[...r]}})};if(m.length>0){let e=setPendingInputBatch({requests:m,responseMessages:l,session:{...h,history:[...r]}});return n&&(await n(createInputRequestedEvent({requests:m,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId})),t.mode===`conversation`&&(o=await emitTurnEpilogue(n,o,t.mode),e=setHarnessEmissionState(e,o))),{next:null,session:e}}let v=pruneToolResults(r,t.retentionPolicies),y=v!==r,b=h.compaction;y&&b.lastKnownInputTokens!==void 0&&(b={recentWindowSize:b.recentWindowSize,threshold:b.threshold});let S=[...v,...l],C={...h,compaction:b,history:S},w=l.at(-1)?.role===`tool`||hasDeferredStepInput(C);return n&&(o=w?advanceStep(o):await emitTurnEpilogue(n,o,t.mode),C=setHarnessEmissionState(C,o)),w?{next:a,session:C}:{next:t.mode===`task`?{done:!0,output:u??``}:null,session:C}}function createNextCompactionConfig(e,t,n){let r={recentWindowSize:e.recentWindowSize,threshold:e.threshold};return n.usage?.inputTokens!==void 0&&(r.lastKnownInputTokens=n.usage.inputTokens,r.lastKnownPromptMessageCount=t.length),r}async function maybeCompact(e){let{emit:t,emissionState:n}=e,r=e.messages,i=e.session;if(!shouldCompact(r,i.compaction))return{messages:r,session:i};let s=await resolveCompactionModel({compactionModelReference:i.agent.compactionModelReference,model:e.model,modelReference:i.agent.modelReference,resolveModel:e.resolveModel});if(t&&await t(createCompactionRequestedEvent({modelId:formatLanguageModelGatewayId(s.model),sequence:n.sequence,sessionId:i.sessionId,turnId:n.turnId,usageInputTokens:getInputTokenCount(r,i.compaction)})),r=await compactMessages(r,s.model,i.compaction,s.providerOptions,e.telemetry,e.headers),e.onCompaction){let t=await e.onCompaction(i);i=t.session;for(let e of t.messages)r.push(e)}return t&&await t(createCompactionCompletedEvent({modelId:formatLanguageModelGatewayId(s.model),sequence:n.sequence,sessionId:i.sessionId,turnId:n.turnId})),{messages:r,session:i}}function resolveApprovalKeyFromTools(e){return t=>{let n=e.get(t.action.toolName);if(n?.approvalKey!==void 0)return n.approvalKey(t.action.input)}}async function runModelCallWithRetries(e,t){for(let n=1;;n++)try{return await e()}catch(e){if(n===MODEL_CALL_MAX_ATTEMPTS||classifyModelCallError(e)!==`retry`)throw e;let r=MODEL_CALL_RETRY_BASE_DELAY_MS*2**(n-1)+Math.floor(Math.random()*250);log.warn(`model call failed transiently — retrying`,{attempt:n,delayMs:r,sessionId:t.sessionId,turnId:t.turnId,error:e}),await new Promise(e=>setTimeout(e,r))}}export{createToolLoopHarness};