experimental-ash 0.25.2 → 0.27.0

package/dist/src/harness/proxy-input-requests.js

@@ -1,91 +1 @@
-const PROXY_INPUT_REQUESTS_KEY = "ash.runtime.proxyInputRequests";
-/**
- * Returns the live `requestId → childContinuationToken` map stored on
- * the session. Always returns a fresh `Map` (never a live reference),
- * so callers may treat the result as read-only without worrying about
- * accidental mutation of session state.
- */
-export function getProxyInputRequests(session) {
-    return new Map(Object.entries(readMap(session)));
-}
-/**
- * Returns true when the session is currently proxying one or more
- * HITL requests on behalf of a descendant subagent.
- */
-export function hasProxyInputRequests(session) {
-    for (const _ of Object.keys(readMap(session))) {
-        return true;
-    }
-    return false;
-}
-/**
- * Replaces any prior entries for `forChildContinuationToken` with the
- * provided `entries`. A child that raises a fresh batch overwrites its
- * previous batch — the parent never keeps stale request metadata.
- */
-export function upsertProxyInputRequests(input) {
-    const next = {};
-    for (const [requestId, childToken] of Object.entries(readMap(input.session))) {
-        if (childToken !== input.forChildContinuationToken) {
-            next[requestId] = childToken;
-        }
-    }
-    for (const [requestId, childToken] of input.entries) {
-        next[requestId] = childToken;
-    }
-    return writeMap(input.session, next);
-}
-/**
- * Removes every entry belonging to `childContinuationToken`. Called
- * when a child subagent finishes (via `resolvePendingRuntimeActions`)
- * so stale button clicks no longer route to a dead child.
- */
-export function clearProxyInputRequestsForChild(session, childContinuationToken) {
-    const current = readMap(session);
-    const next = {};
-    let changed = false;
-    for (const [requestId, childToken] of Object.entries(current)) {
-        if (childToken === childContinuationToken) {
-            changed = true;
-            continue;
-        }
-        next[requestId] = childToken;
-    }
-    if (!changed) {
-        return session;
-    }
-    return writeMap(session, next);
-}
-/**
- * Projects one child {@link SubagentInputRequestHookPayload} into the
- * `(requestId, childContinuationToken)` tuples the parent session
- * stores. Pure — does not touch session state.
- */
-export function toProxyInputRequestEntries(payload) {
-    return payload.event.requests.map((request) => [request.requestId, payload.childContinuationToken]);
-}
-function readMap(session) {
-    const raw = session.state?.[PROXY_INPUT_REQUESTS_KEY];
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-        return {};
-    }
-    const result = {};
-    for (const [key, value] of Object.entries(raw)) {
-        if (typeof value === "string") {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-function writeMap(session, entries) {
-    const state = { ...session.state };
-    if (Object.keys(entries).length === 0) {
-        delete state[PROXY_INPUT_REQUESTS_KEY];
-        return {
-            ...session,
-            state: Object.keys(state).length > 0 ? state : undefined,
-        };
-    }
-    state[PROXY_INPUT_REQUESTS_KEY] = entries;
-    return { ...session, state };
-}
+var PROXY_INPUT_REQUESTS_KEY=`ash.runtime.proxyInputRequests`;function getProxyInputRequests(e){return new Map(Object.entries(readMap(e)))}function hasProxyInputRequests(e){for(let t of Object.keys(readMap(e)))return!0;return!1}function upsertProxyInputRequests(e){let t={};for(let[n,r]of Object.entries(readMap(e.session)))r!==e.forChildContinuationToken&&(t[n]=r);for(let[n,r]of e.entries)t[n]=r;return writeMap(e.session,t)}function clearProxyInputRequestsForChild(e,t){let n=readMap(e),r={},i=!1;for(let[e,a]of Object.entries(n)){if(a===t){i=!0;continue}r[e]=a}return i?writeMap(e,r):e}function toProxyInputRequestEntries(e){return e.event.requests.map(t=>[t.requestId,e.childContinuationToken])}function readMap(t){let n=t.state?.[PROXY_INPUT_REQUESTS_KEY];if(typeof n!=`object`||!n||Array.isArray(n))return{};let r={};for(let[e,t]of Object.entries(n))typeof t==`string`&&(r[e]=t);return r}function writeMap(t,n){let r={...t.state};return Object.keys(n).length===0?(delete r[PROXY_INPUT_REQUESTS_KEY],{...t,state:Object.keys(r).length>0?r:void 0}):(r[PROXY_INPUT_REQUESTS_KEY]=n,{...t,state:r})}export{clearProxyInputRequestsForChild,getProxyInputRequests,hasProxyInputRequests,toProxyInputRequestEntries,upsertProxyInputRequests};

package/dist/src/harness/runtime-actions.js

@@ -1,321 +1 @@
-import { createActionResultEvent } from "#protocol/message.js";
-import { getRuntimeActionRequestKey, getRuntimeActionResultKey } from "#runtime/actions/keys.js";
-import { parseJsonObject } from "#shared/json.js";
-import { clearProxyInputRequestsForChild } from "#harness/proxy-input-requests.js";
-const PENDING_RUNTIME_ACTION_BATCH_KEY = "ash.runtime.pendingActionBatch";
-/**
- * Returns the pending runtime-action batch stored on the session, if any.
- */
-export function getPendingRuntimeActionBatch(session) {
-    const value = session.state?.[PENDING_RUNTIME_ACTION_BATCH_KEY];
-    if (typeof value !== "object" || value === null) {
-        return undefined;
-    }
-    const batch = value;
-    if (!Array.isArray(batch.actions) ||
-        !Array.isArray(batch.responseMessages) ||
-        typeof batch.event !== "object" ||
-        batch.event === null) {
-        return undefined;
-    }
-    return batch;
-}
-/**
- * Returns true when the session is parked on a pending runtime-action batch.
- */
-export function hasPendingRuntimeActionBatch(session) {
-    return getPendingRuntimeActionBatch(session) !== undefined;
-}
-/**
- * Stores one pending runtime-action batch on the session.
- */
-export function setPendingRuntimeActionBatch(input) {
-    const state = { ...input.session.state };
-    state[PENDING_RUNTIME_ACTION_BATCH_KEY] = {
-        actions: [...input.actions],
-        event: input.event,
-        responseMessages: [...input.responseMessages],
-    };
-    return { ...input.session, state };
-}
-/**
- * Records the child continuation token minted for one dispatched
- * subagent-call action onto the pending batch so {@link
- * resolvePendingRuntimeActions} can clear the matching proxy-input
- * entries when the child finishes.
- */
-export function recordPendingSubagentChildToken(input) {
-    const batch = getPendingRuntimeActionBatch(input.session);
-    if (batch === undefined) {
-        return input.session;
-    }
-    const state = { ...input.session.state };
-    state[PENDING_RUNTIME_ACTION_BATCH_KEY] = {
-        ...batch,
-        childContinuationTokens: {
-            ...batch.childContinuationTokens,
-            [input.callId]: input.childContinuationToken,
-        },
-    };
-    return { ...input.session, state };
-}
-/**
- * Accumulates runtime-action results from a mixed stream of items until
- * every pending action in the batch has a matching result.
- */
-export async function accumulateRuntimeActionResults(input) {
-    const batch = getPendingRuntimeActionBatch(input.session);
-    const buffered = [...(input.initialResults ?? [])];
-    if (batch !== undefined && buffered.length > 0) {
-        const ready = resolveRuntimeActionResultsForBatch({ batch, results: buffered });
-        if (ready !== undefined) {
-            return ready;
-        }
-    }
-    while (true) {
-        const item = await input.getNext();
-        if (item === null) {
-            return null;
-        }
-        if (item.kind === "deliver") {
-            input.bufferedDeliveries.push(item.value);
-            continue;
-        }
-        buffered.push(...item.results);
-        if (batch === undefined) {
-            // No pending batch at call time; there is nothing to resolve
-            // against. Keep draining results so the caller's stream state
-            // stays consistent, but never return a non-null result.
-            continue;
-        }
-        const ready = resolveRuntimeActionResultsForBatch({ batch, results: buffered });
-        if (ready !== undefined) {
-            return ready;
-        }
-    }
-}
-/**
- * Returns the stable ordered runtime-action results for the current pending
- * batch when every action has a matching result. Unknown and duplicate results
- * are ignored.
- */
-function resolveReadyRuntimeActionResults(input) {
-    const batch = getPendingRuntimeActionBatch(input.session);
-    if (batch === undefined) {
-        return undefined;
-    }
-    return resolveRuntimeActionResultsForBatch({ batch, results: input.results });
-}
-function resolveRuntimeActionResultsForBatch(input) {
-    const { batch } = input;
-    const pendingKeys = new Set(batch.actions.map((action) => getRuntimeActionRequestKey(action)));
-    const resultsByKey = new Map();
-    for (const result of input.results) {
-        const key = getRuntimeActionResultKey(result);
-        if (!pendingKeys.has(key)) {
-            continue;
-        }
-        resultsByKey.set(key, result);
-    }
-    const orderedResults = [];
-    for (const action of batch.actions) {
-        const key = getRuntimeActionRequestKey(action);
-        const result = resultsByKey.get(key);
-        if (result === undefined) {
-            return undefined;
-        }
-        orderedResults.push(result);
-    }
-    return orderedResults;
-}
-/**
- * Resolves one pending runtime-action batch back into model history.
- *
- * When all expected runtime action results are present, this appends the
- * stored assistant tool-call messages plus synthesized tool-result messages to
- * history, clears the pending batch, and emits `subagent.completed` and
- * `action.result` events back onto the parent stream.
- */
-export async function resolvePendingRuntimeActions(input) {
-    const batch = getPendingRuntimeActionBatch(input.session);
-    if (batch === undefined) {
-        return {
-            messages: [...input.session.history],
-            outcome: "continue",
-            session: input.session,
-        };
-    }
-    const readyResults = resolveReadyRuntimeActionResults({
-        results: input.stepInput?.runtimeActionResults ?? [],
-        session: input.session,
-    });
-    if (readyResults === undefined) {
-        return {
-            messages: [...input.session.history],
-            outcome: "unresolved",
-            session: input.session,
-        };
-    }
-    if (input.emit !== undefined) {
-        for (const result of readyResults) {
-            if (result.kind === "subagent-result" && result.isError !== true) {
-                await input.emit({
-                    data: {
-                        callId: result.callId,
-                        output: typeof result.output === "string" ? result.output : JSON.stringify(result.output),
-                        subagentName: result.subagentName,
-                    },
-                    type: "subagent.completed",
-                });
-            }
-            await input.emit(createActionResultEvent({
-                result,
-                sequence: batch.event.sequence,
-                stepIndex: batch.event.stepIndex,
-                turnId: batch.event.turnId,
-            }));
-        }
-    }
-    const state = { ...input.session.state };
-    delete state[PENDING_RUNTIME_ACTION_BATCH_KEY];
-    let nextSession = {
-        ...input.session,
-        state: Object.keys(state).length > 0 ? state : undefined,
-    };
-    // Clear any proxy-input-request entries that belong to the completed
-    // children so future deliveries never route responses to a child
-    // that has already finished. The dispatch site recorded each child's
-    // continuation token on the batch via `recordPendingSubagentChildToken`
-    // so the harness never has to reach back into runtime/execution code
-    // to re-derive the token (AGENTS.md #14 — harness stays runtime-agnostic).
-    const childTokens = batch.childContinuationTokens;
-    if (childTokens !== undefined) {
-        for (const result of readyResults) {
-            if (result.kind !== "subagent-result") {
-                continue;
-            }
-            const childToken = childTokens[result.callId];
-            if (childToken !== undefined) {
-                nextSession = clearProxyInputRequestsForChild(nextSession, childToken);
-            }
-        }
-    }
-    const toolResults = readyResults.map((result) => {
-        switch (result.kind) {
-            case "load-skill-result":
-                return {
-                    output: toToolResultOutput(result),
-                    toolCallId: result.callId,
-                    toolName: "load_skill",
-                    type: "tool-result",
-                };
-            case "subagent-result":
-                return {
-                    output: toToolResultOutput(result),
-                    toolCallId: result.callId,
-                    toolName: result.subagentName,
-                    type: "tool-result",
-                };
-            case "tool-result":
-                return {
-                    output: toToolResultOutput(result),
-                    toolCallId: result.callId,
-                    toolName: result.toolName,
-                    type: "tool-result",
-                };
-        }
-        throw new Error(`Unsupported runtime action result kind "${String(result)}".`);
-    });
-    const messages = [...nextSession.history, ...batch.responseMessages];
-    if (toolResults.length > 0) {
-        messages.push({
-            content: toolResults,
-            role: "tool",
-        });
-    }
-    return {
-        messages,
-        outcome: "resolved",
-        session: nextSession,
-    };
-}
-/**
- * Projects one AI SDK tool call into the Ash runtime-action contract.
- */
-export function createRuntimeActionRequestFromToolCall(input) {
-    const definition = input.tools.get(input.toolCall.toolName);
-    if (definition?.runtimeAction?.kind === "subagent-call") {
-        return {
-            callId: input.toolCall.toolCallId,
-            description: definition.description,
-            input: resolveToolCallInputObject(input.toolCall.input),
-            kind: "subagent-call",
-            name: definition.name,
-            nodeId: definition.runtimeAction.nodeId,
-            subagentName: definition.runtimeAction.subagentName,
-        };
-    }
-    if (definition?.runtimeAction?.kind === "remote-agent-call") {
-        return {
-            callId: input.toolCall.toolCallId,
-            description: definition.description,
-            input: resolveToolCallInputObject(input.toolCall.input),
-            kind: "remote-agent-call",
-            name: definition.name,
-            nodeId: definition.runtimeAction.nodeId,
-            remoteAgentName: definition.runtimeAction.remoteAgentName ?? definition.name,
-        };
-    }
-    return {
-        callId: input.toolCall.toolCallId,
-        input: resolveToolCallInputObject(input.toolCall.input),
-        kind: "tool-call",
-        toolName: input.toolCall.toolName,
-    };
-}
-function resolveToolCallInputObject(value) {
-    if (value === undefined || value === null) {
-        return {};
-    }
-    return parseJsonObject(value);
-}
-function toToolResultOutput(result) {
-    if (typeof result.output === "string") {
-        if (result.isError === true) {
-            return {
-                type: "error-text",
-                value: result.output,
-            };
-        }
-        return {
-            type: "text",
-            value: result.output,
-        };
-    }
-    if (result.isError === true) {
-        return {
-            type: "error-json",
-            value: toMutableJsonValue(result.output),
-        };
-    }
-    return {
-        type: "json",
-        value: toMutableJsonValue(result.output),
-    };
-}
-function toMutableJsonValue(value) {
-    if (value === null ||
-        typeof value === "string" ||
-        typeof value === "number" ||
-        typeof value === "boolean") {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => toMutableJsonValue(item));
-    }
-    const next = {};
-    for (const [key, item] of Object.entries(value)) {
-        next[key] = toMutableJsonValue(item);
-    }
-    return next;
-}
+import{createActionResultEvent}from"#protocol/message.js";import{parseJsonObject}from"#shared/json.js";import{clearProxyInputRequestsForChild}from"#harness/proxy-input-requests.js";import{getRuntimeActionRequestKey,getRuntimeActionResultKey}from"#runtime/actions/keys.js";var PENDING_RUNTIME_ACTION_BATCH_KEY=`ash.runtime.pendingActionBatch`;function getPendingRuntimeActionBatch(e){let t=e.state?.[PENDING_RUNTIME_ACTION_BATCH_KEY];if(typeof t!=`object`||!t)return;let n=t;if(!(!Array.isArray(n.actions)||!Array.isArray(n.responseMessages)||typeof n.event!=`object`||n.event===null))return n}function hasPendingRuntimeActionBatch(e){return getPendingRuntimeActionBatch(e)!==void 0}function setPendingRuntimeActionBatch(e){let t={...e.session.state};return t[PENDING_RUNTIME_ACTION_BATCH_KEY]={actions:[...e.actions],event:e.event,responseMessages:[...e.responseMessages]},{...e.session,state:t}}function recordPendingSubagentChildToken(e){let t=getPendingRuntimeActionBatch(e.session);if(t===void 0)return e.session;let n={...e.session.state};return n[PENDING_RUNTIME_ACTION_BATCH_KEY]={...t,childContinuationTokens:{...t.childContinuationTokens,[e.callId]:e.childContinuationToken}},{...e.session,state:n}}async function accumulateRuntimeActionResults(e){let t=getPendingRuntimeActionBatch(e.session),n=[...e.initialResults??[]];if(t!==void 0&&n.length>0){let e=resolveRuntimeActionResultsForBatch({batch:t,results:n});if(e!==void 0)return e}for(;;){let r=await e.getNext();if(r===null)return null;if(r.kind===`deliver`){e.bufferedDeliveries.push(r.value);continue}if(n.push(...r.results),t===void 0)continue;let i=resolveRuntimeActionResultsForBatch({batch:t,results:n});if(i!==void 0)return i}}function resolveReadyRuntimeActionResults(e){let t=getPendingRuntimeActionBatch(e.session);if(t!==void 0)return resolveRuntimeActionResultsForBatch({batch:t,results:e.results})}function resolveRuntimeActionResultsForBatch(e){let{batch:t}=e,n=new Set(t.actions.map(e=>getRuntimeActionRequestKey(e))),a=new Map;for(let t of e.results){let e=getRuntimeActionResultKey(t);n.has(e)&&a.set(e,t)}let o=[];for(let e of t.actions){let t=getRuntimeActionRequestKey(e),n=a.get(t);if(n===void 0)return;o.push(n)}return o}async function resolvePendingRuntimeActions(t){let r=getPendingRuntimeActionBatch(t.session);if(r===void 0)return{messages:[...t.session.history],outcome:`continue`,session:t.session};let i=resolveReadyRuntimeActionResults({results:t.stepInput?.runtimeActionResults??[],session:t.session});if(i===void 0)return{messages:[...t.session.history],outcome:`unresolved`,session:t.session};if(t.emit!==void 0)for(let n of i)n.kind===`subagent-result`&&n.isError!==!0&&await t.emit({data:{callId:n.callId,output:typeof n.output==`string`?n.output:JSON.stringify(n.output),subagentName:n.subagentName},type:`subagent.completed`}),await t.emit(createActionResultEvent({result:n,sequence:r.event.sequence,stepIndex:r.event.stepIndex,turnId:r.event.turnId}));let o={...t.session.state};delete o[PENDING_RUNTIME_ACTION_BATCH_KEY];let s={...t.session,state:Object.keys(o).length>0?o:void 0},c=r.childContinuationTokens;if(c!==void 0)for(let e of i){if(e.kind!==`subagent-result`)continue;let t=c[e.callId];t!==void 0&&(s=clearProxyInputRequestsForChild(s,t))}let l=i.map(e=>{switch(e.kind){case`load-skill-result`:return{output:toToolResultOutput(e),toolCallId:e.callId,toolName:`load_skill`,type:`tool-result`};case`subagent-result`:return{output:toToolResultOutput(e),toolCallId:e.callId,toolName:e.subagentName,type:`tool-result`};case`tool-result`:return{output:toToolResultOutput(e),toolCallId:e.callId,toolName:e.toolName,type:`tool-result`}}throw Error(`Unsupported runtime action result kind "${String(e)}".`)}),u=[...s.history,...r.responseMessages];return l.length>0&&u.push({content:l,role:`tool`}),{messages:u,outcome:`resolved`,session:s}}function createRuntimeActionRequestFromToolCall(e){let t=e.tools.get(e.toolCall.toolName);return t?.runtimeAction?.kind===`subagent-call`?{callId:e.toolCall.toolCallId,description:t.description,input:resolveToolCallInputObject(e.toolCall.input),kind:`subagent-call`,name:t.name,nodeId:t.runtimeAction.nodeId,subagentName:t.runtimeAction.subagentName}:t?.runtimeAction?.kind===`remote-agent-call`?{callId:e.toolCall.toolCallId,description:t.description,input:resolveToolCallInputObject(e.toolCall.input),kind:`remote-agent-call`,name:t.name,nodeId:t.runtimeAction.nodeId,remoteAgentName:t.runtimeAction.remoteAgentName??t.name}:{callId:e.toolCall.toolCallId,input:resolveToolCallInputObject(e.toolCall.input),kind:`tool-call`,toolName:e.toolCall.toolName}}function resolveToolCallInputObject(e){return e==null?{}:parseJsonObject(e)}function toToolResultOutput(e){return typeof e.output==`string`?e.isError===!0?{type:`error-text`,value:e.output}:{type:`text`,value:e.output}:e.isError===!0?{type:`error-json`,value:toMutableJsonValue(e.output)}:{type:`json`,value:toMutableJsonValue(e.output)}}function toMutableJsonValue(e){if(e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`)return e;if(Array.isArray(e))return e.map(e=>toMutableJsonValue(e));let t={};for(let[n,r]of Object.entries(e))t[n]=toMutableJsonValue(r);return t}export{accumulateRuntimeActionResults,createRuntimeActionRequestFromToolCall,getPendingRuntimeActionBatch,hasPendingRuntimeActionBatch,recordPendingSubagentChildToken,resolvePendingRuntimeActions,setPendingRuntimeActionBatch};

package/dist/src/harness/step-hooks.js

@@ -1,192 +1 @@
-import { createActionResultEvent, createActionsRequestedEvent, createStepCompletedEvent, } from "#protocol/message.js";
-import { createRuntimeToolResultFromMessagePart, createRuntimeToolResultFromStepResult, } from "#harness/action-result-helpers.js";
-import { emitStepStarted, normalizeAssistantStepFinishReason } from "#harness/emission.js";
-import { extractToolApprovalInputRequests } from "#harness/input-extraction.js";
-import { applyConversationCacheControl, mergeGatewayAutoCaching, } from "#harness/prompt-cache.js";
-import { mergeGatewayProviderPin } from "#harness/provider-tools.js";
-import { createRuntimeActionRequestFromToolCall } from "#harness/runtime-actions.js";
-// ---------------------------------------------------------------------------
-// Builder
-// ---------------------------------------------------------------------------
-/**
- * Builds composable `prepareStep` and `onStepFinish` closures that
- * own all step-internal work: emission, compaction, and prompt caching.
- *
- * The harness passes these hooks to `ToolLoopAgent` and reads the
- * results via `getSession()` and `stepResult` after the agent finishes.
- */
-export function buildStepHooks(input) {
-    const session = input.session;
-    const emit = input.emit;
-    let resolveStep;
-    const stepResult = new Promise((resolve) => {
-        resolveStep = resolve;
-    });
-    // -------------------------------------------------------------------------
-    // prepareStep
-    //
-    // Only handles step.started emission and cache/provider metadata. Compaction
-    // runs in the tool-loop before `agent.stream()` so the compacted messages
-    // flow through the same `messages` variable the harness uses to rebuild
-    // session history — no prepareStep snapshot required.
-    // -------------------------------------------------------------------------
-    const prepareStep = async ({ messages }) => {
-        let processed = messages;
-        if (emit && input.emitStepStarted !== false) {
-            await emitStepStarted(emit, input.emissionState);
-        }
-        if (input.cachePath.kind === "anthropic-direct" && input.marker) {
-            processed = applyConversationCacheControl([...messages], input.marker);
-        }
-        const stepResult = {
-            messages: processed,
-        };
-        if (input.cachePath.kind === "gateway-auto") {
-            let providerOptions = mergeGatewayAutoCaching(session.agent.modelReference.providerOptions);
-            if (input.gatewayPinProvider !== undefined) {
-                providerOptions = mergeGatewayProviderPin(providerOptions, input.gatewayPinProvider);
-            }
-            stepResult.providerOptions = providerOptions;
-        }
-        return stepResult;
-    };
-    return {
-        onStepFinish: async (step) => {
-            resolveStep(step);
-        },
-        prepareStep,
-        stepResult,
-    };
-}
-// ---------------------------------------------------------------------------
-// Step action emission
-// ---------------------------------------------------------------------------
-/**
- * Emits `actions.requested`, `action.result`, and `step.completed` events
- * from a captured step result.
- *
- * Tool calls and results that match `excludedActionToolNames`, belong to
- * tool-approval requests, or are marked `invalid` by the AI SDK (e.g. the
- * model emitted unparsable JSON) are filtered out of the emitted events.
- * The AI SDK feeds the invalid-call error back to the model on the next
- * step via `step.response.messages` so it can retry with well-formed
- * arguments — the runtime event stream only sees successfully parsed
- * tool calls.
- *
- * `inlineActionResultCallIds` lists tool-result call ids the stream
- * already surfaced as `action.result` events (approval-resume path —
- * see `emitStreamContent`). This skips them to avoid double-emission.
- */
-export async function emitStepActions(emitFn, state, step, options) {
-    const excludedCallIds = new Set([
-        ...extractToolApprovalInputRequests({
-            content: (step.content ?? []),
-        }).map((request) => request.action.callId),
-        ...step.toolCalls
-            .filter(isInvalidToolCall)
-            .map((toolCall) => toolCall.toolCallId),
-    ]);
-    const isExcluded = (toolCallId, toolName) => excludedCallIds.has(toolCallId) || options.excludedActionToolNames.has(toolName);
-    // actions.requested
-    const actions = step.toolCalls
-        .filter((tc) => !isExcluded(tc.toolCallId, tc.toolName))
-        .map((toolCall) => createRuntimeActionRequestFromToolCall({
-        toolCall,
-        tools: options.tools,
-    }));
-    if (actions.length > 0) {
-        await emitFn(createActionsRequestedEvent({
-            actions,
-            sequence: state.sequence,
-            stepIndex: state.stepIndex,
-            turnId: state.turnId,
-        }));
-    }
-    const inlineCallIds = options.inlineActionResultCallIds;
-    for (const result of reconcileToolResults(step)) {
-        if (isExcluded(result.callId, result.toolName)) {
-            continue;
-        }
-        if (inlineCallIds?.has(result.callId)) {
-            continue;
-        }
-        await emitFn(createActionResultEvent({
-            result,
-            sequence: state.sequence,
-            stepIndex: state.stepIndex,
-            turnId: state.turnId,
-        }));
-    }
-    // step.completed
-    await emitFn(createStepCompletedEvent({
-        finishReason: normalizeAssistantStepFinishReason(step.finishReason),
-        sequence: state.sequence,
-        stepIndex: state.stepIndex,
-        turnId: state.turnId,
-        usage: extractStepUsage(step.usage),
-    }));
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/**
- * Returns true when the AI SDK marked the tool call `invalid` (typically
- * because the model emitted unparsable JSON or targeted an unknown tool).
- *
- * Invalid calls have a raw-string or partial `input` payload that cannot
- * satisfy the runtime-action contract. The AI SDK synthesizes a tool-error
- * result for the next model step automatically; callers must skip invalid
- * calls when projecting to `RuntimeActionRequest` values or the harness
- * will throw on the JSON-object invariant.
- */
-export function isInvalidToolCall(toolCall) {
-    return toolCall.invalid === true;
-}
-function reconcileToolResults(step) {
-    const resultsByCallId = new Map();
-    for (const toolResult of step.toolResults) {
-        resultsByCallId.set(toolResult.toolCallId, createRuntimeToolResultFromStepResult(toolResult));
-    }
-    for (const part of extractToolResultParts(step.response.messages)) {
-        if (resultsByCallId.has(part.toolCallId)) {
-            continue;
-        }
-        resultsByCallId.set(part.toolCallId, createRuntimeToolResultFromMessagePart(part));
-    }
-    return [...resultsByCallId.values()];
-}
-function extractToolResultParts(messages) {
-    const parts = [];
-    for (const message of messages) {
-        if (message.role !== "tool" || !Array.isArray(message.content)) {
-            continue;
-        }
-        for (const part of message.content) {
-            if (part.type === "tool-result") {
-                parts.push(part);
-            }
-        }
-    }
-    return parts;
-}
-/**
- * Projects the AI SDK's `LanguageModelUsage` into the flat `step.completed`
- * event usage shape. Returns `undefined` when the SDK reports no usage.
- */
-function extractStepUsage(usage) {
-    if (usage === undefined) {
-        return undefined;
-    }
-    const result = {};
-    if (usage.inputTokens !== undefined)
-        result.inputTokens = usage.inputTokens;
-    if (usage.outputTokens !== undefined)
-        result.outputTokens = usage.outputTokens;
-    if (usage.inputTokenDetails?.cacheReadTokens !== undefined) {
-        result.cacheReadTokens = usage.inputTokenDetails.cacheReadTokens;
-    }
-    if (usage.inputTokenDetails?.cacheWriteTokens !== undefined) {
-        result.cacheWriteTokens = usage.inputTokenDetails.cacheWriteTokens;
-    }
-    return Object.keys(result).length > 0 ? result : undefined;
-}
+import{createActionResultEvent,createActionsRequestedEvent,createStepCompletedEvent}from"#protocol/message.js";import{createRuntimeToolResultFromMessagePart,createRuntimeToolResultFromStepResult}from"#harness/action-result-helpers.js";import{emitStepStarted,normalizeAssistantStepFinishReason}from"#harness/emission.js";import{createRuntimeActionRequestFromToolCall}from"#harness/runtime-actions.js";import{extractToolApprovalInputRequests}from"#harness/input-extraction.js";import{applyConversationCacheControl,mergeGatewayAutoCaching}from"#harness/prompt-cache.js";import{mergeGatewayProviderPin}from"#harness/provider-tools.js";function buildStepHooks(e){let t=e.session,n=e.emit,r;return{onStepFinish:async e=>{r(e)},prepareStep:async({messages:r})=>{let i=r;n&&e.emitStepStarted!==!1&&await emitStepStarted(n,e.emissionState),e.cachePath.kind===`anthropic-direct`&&e.marker&&(i=applyConversationCacheControl([...r],e.marker));let o={messages:i};if(e.cachePath.kind===`gateway-auto`){let n=mergeGatewayAutoCaching(t.agent.modelReference.providerOptions);e.gatewayPinProvider!==void 0&&(n=mergeGatewayProviderPin(n,e.gatewayPinProvider)),o.providerOptions=n}return o},stepResult:new Promise(e=>{r=e})}}async function emitStepActions(r,i,a,s){let c=new Set([...extractToolApprovalInputRequests({content:a.content??[]}).map(e=>e.action.callId),...a.toolCalls.filter(isInvalidToolCall).map(e=>e.toolCallId)]),isExcluded=(e,t)=>c.has(e)||s.excludedActionToolNames.has(t),l=a.toolCalls.filter(e=>!isExcluded(e.toolCallId,e.toolName)).map(e=>createRuntimeActionRequestFromToolCall({toolCall:e,tools:s.tools}));l.length>0&&await r(createActionsRequestedEvent({actions:l,sequence:i.sequence,stepIndex:i.stepIndex,turnId:i.turnId}));let u=s.inlineActionResultCallIds;for(let t of reconcileToolResults(a))isExcluded(t.callId,t.toolName)||u?.has(t.callId)||await r(createActionResultEvent({result:t,sequence:i.sequence,stepIndex:i.stepIndex,turnId:i.turnId}));await r(createStepCompletedEvent({finishReason:normalizeAssistantStepFinishReason(a.finishReason),sequence:i.sequence,stepIndex:i.stepIndex,turnId:i.turnId,usage:extractStepUsage(a.usage)}))}function isInvalidToolCall(e){return e.invalid===!0}function reconcileToolResults(e){let t=new Map;for(let n of e.toolResults)t.set(n.toolCallId,createRuntimeToolResultFromStepResult(n));for(let n of extractToolResultParts(e.response.messages))t.has(n.toolCallId)||t.set(n.toolCallId,createRuntimeToolResultFromMessagePart(n));return[...t.values()]}function extractToolResultParts(e){let t=[];for(let n of e)if(!(n.role!==`tool`||!Array.isArray(n.content)))for(let e of n.content)e.type===`tool-result`&&t.push(e);return t}function extractStepUsage(e){if(e===void 0)return;let t={};return e.inputTokens!==void 0&&(t.inputTokens=e.inputTokens),e.outputTokens!==void 0&&(t.outputTokens=e.outputTokens),e.inputTokenDetails?.cacheReadTokens!==void 0&&(t.cacheReadTokens=e.inputTokenDetails.cacheReadTokens),e.inputTokenDetails?.cacheWriteTokens!==void 0&&(t.cacheWriteTokens=e.inputTokenDetails.cacheWriteTokens),Object.keys(t).length>0?t:void 0}export{buildStepHooks,emitStepActions,isInvalidToolCall};