experimental-ash 0.26.0 → 0.28.0

package/dist/src/harness/emission.js

@@ -1,323 +1 @@
-import { createActionResultEvent, createMessageAppendedEvent, createMessageCompletedEvent, createMessageReceivedEvent, createReasoningAppendedEvent, createReasoningCompletedEvent, createSessionCompletedEvent, createSessionFailedEvent, createSessionStartedEvent, createSessionWaitingEvent, createStepFailedEvent, createStepStartedEvent, createTurnCompletedEvent, createTurnFailedEvent, createTurnStartedEvent, } from "#protocol/message.js";
-import { toError } from "#shared/errors.js";
-import { createRuntimeToolResultFromStepResult } from "#harness/action-result-helpers.js";
-const HARNESS_EMISSION_STATE_KEY = "ash.harness.emission";
-const DEFAULT_EMISSION_STATE = {
-    sessionStarted: false,
-    sequence: 0,
-    stepIndex: 0,
-    turnId: "",
-};
-/**
- * Reads the emission state from the session, returning defaults when absent.
- */
-export function getHarnessEmissionState(session) {
-    const emissionState = session.state?.[HARNESS_EMISSION_STATE_KEY];
-    return emissionState ?? DEFAULT_EMISSION_STATE;
-}
-/**
- * Returns `true` when the harness is **between turns** — either no turn
- * has started yet (initial state) or the previous turn has emitted its
- * epilogue (or recoverable failure cascade) and reset.
- *
- * Returns `false` while a turn is in progress, including during
- * tool-loop continuations and runtime-action resumes within the same
- * turn. Callers that gate per-turn work (eg. lifecycle hook dispatch)
- * use this predicate to distinguish a fresh delivery from a
- * continuation of an in-flight turn.
- *
- * Implemented over the empty-`turnId` sentinel that `emitTurnEpilogue`
- * and `emitRecoverableFailedTurn` write — clients should never read
- * `state.turnId` directly to make this distinction.
- */
-export function isHarnessBetweenTurns(session) {
-    return getHarnessEmissionState(session).turnId === "";
-}
-/**
- * Writes the emission state onto a new copy of the session.
- */
-export function setHarnessEmissionState(session, state) {
-    return {
-        ...session,
-        state: {
-            ...session.state,
-            [HARNESS_EMISSION_STATE_KEY]: state,
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// Turn lifecycle helpers
-// ---------------------------------------------------------------------------
-/**
- * Emits `session.started` (once), `turn.started`, and `message.received` at the
- * beginning of a new turn. Returns updated emission state.
- */
-export async function emitTurnPreamble(emitFn, input, state, runtimeIdentity) {
-    const turnId = `turn_${state.sequence}`;
-    if (!state.sessionStarted) {
-        await emitFn(createSessionStartedEvent({ runtime: runtimeIdentity }));
-    }
-    await emitFn(createTurnStartedEvent({ sequence: state.sequence, turnId }));
-    if (input.message !== undefined) {
-        await emitFn(createMessageReceivedEvent({
-            message: input.message,
-            sequence: state.sequence,
-            turnId,
-        }));
-    }
-    return {
-        sessionStarted: true,
-        sequence: state.sequence,
-        stepIndex: 0,
-        turnId,
-    };
-}
-/**
- * Emits `step.started` for one model call.
- */
-export async function emitStepStarted(emitFn, state) {
-    await emitFn(createStepStartedEvent({
-        sequence: state.sequence,
-        stepIndex: state.stepIndex,
-        turnId: state.turnId,
-    }));
-}
-/**
- * Emits the shared head of both failure cascades: `step.failed` →
- * `turn.failed`. Both terminal and recoverable paths diverge only on
- * the third event (`session.failed` vs. `session.waiting`).
- */
-async function emitStepAndTurnFailed(emitFn, state, input) {
-    await emitFn(createStepFailedEvent({
-        ...input,
-        sequence: state.sequence,
-        stepIndex: state.stepIndex,
-        turnId: state.turnId,
-    }));
-    await emitFn(createTurnFailedEvent({
-        ...input,
-        sequence: state.sequence,
-        turnId: state.turnId,
-    }));
-}
-/**
- * Emits the full terminal failure cascade: `step.failed` →
- * `turn.failed` → `session.failed`.
- *
- * Use this when the session cannot be salvaged (structural config
- * error, auth misconfig, non-recoverable provider response). The
- * `session.failed` tail tells adapters the session is dead and no
- * further follow-up is possible on the same continuation token.
- */
-export async function emitFailedStep(emitFn, state, input) {
-    await emitStepAndTurnFailed(emitFn, state, input);
-    await emitFn(createSessionFailedEvent(input));
-}
-/**
- * Emits the recoverable failure cascade: `step.failed` →
- * `turn.failed` → `session.waiting`.
- */
-export async function emitRecoverableFailedTurn(emitFn, state, input) {
-    await emitStepAndTurnFailed(emitFn, state, input);
-    await emitFn(createSessionWaitingEvent());
-    return {
-        sessionStarted: state.sessionStarted,
-        sequence: state.sequence + 1,
-        stepIndex: 0,
-        turnId: "",
-    };
-}
-/**
- * Returns updated emission state for the next step in the current turn.
- */
-export function advanceStep(state) {
-    return {
-        ...state,
-        stepIndex: state.stepIndex + 1,
-    };
-}
-/**
- * Emits `turn.completed` and either `session.waiting` or `session.completed`.
- * Returns updated emission state with an incremented sequence.
- */
-export async function emitTurnEpilogue(emitFn, state, mode) {
-    await emitFn(createTurnCompletedEvent({
-        sequence: state.sequence,
-        turnId: state.turnId,
-    }));
-    if (mode === "conversation") {
-        await emitFn(createSessionWaitingEvent());
-    }
-    else {
-        await emitFn(createSessionCompletedEvent());
-    }
-    return {
-        sessionStarted: state.sessionStarted,
-        sequence: state.sequence + 1,
-        stepIndex: 0,
-        turnId: "",
-    };
-}
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-/**
- * Maps an AI SDK finish reason string to the Ash-owned
- * {@link AssistantStepFinishReason} union. Unknown values become `"other"`.
- */
-export function normalizeAssistantStepFinishReason(value) {
-    switch (value) {
-        case "content-filter":
-        case "error":
-        case "length":
-        case "stop":
-        case "tool-calls":
-            return value;
-        default:
-            return "other";
-    }
-}
-/**
- * Consumes the AI SDK `fullStream` and emits real-time text and reasoning
- * events.
- *
- * `tool-result` parts that have no preceding `tool-call` in this stream
- * are emitted inline as `action.result` events. This is the
- * approval-resume path: when a previously-parked tool call is approved,
- * the AI SDK enqueues the executed tool-result onto the same step's
- * stream before the next LLM call. Emitting `action.result` inline keeps
- * it ahead of the message events that depend on it.
- *
- * Tool-call, tool-approval-request, and non-resumed tool-result events
- * are still emitted by `emitStepActions` from the `onStepFinish`
- * callback so the existing single-step batch ordering is preserved.
- */
-export async function emitStreamContent(emitFn, state, fullStream) {
-    let currentReasoning = "";
-    let currentMessage = "";
-    let finishReason = "stop";
-    let streamError;
-    const toolCallIdsSeenInStream = new Set();
-    const inlineActionResultCallIds = new Set();
-    const inlineToolResultParts = [];
-    const flushCurrentMessage = async () => {
-        if (currentMessage.length === 0) {
-            return;
-        }
-        await emitFn(createMessageCompletedEvent({
-            finishReason: "tool-calls",
-            message: currentMessage,
-            sequence: state.sequence,
-            stepIndex: state.stepIndex,
-            turnId: state.turnId,
-        }));
-        currentMessage = "";
-    };
-    for await (const part of fullStream) {
-        if (streamError !== undefined) {
-            continue;
-        }
-        switch (part.type) {
-            case "reasoning-delta":
-                currentReasoning += part.text;
-                await emitFn(createReasoningAppendedEvent({
-                    reasoningDelta: part.text,
-                    reasoningSoFar: currentReasoning,
-                    sequence: state.sequence,
-                    stepIndex: state.stepIndex,
-                    turnId: state.turnId,
-                }));
-                break;
-            case "text-delta":
-                // Flush accumulated reasoning before text begins.
-                if (currentReasoning.trim().length > 0) {
-                    await emitFn(createReasoningCompletedEvent({
-                        reasoning: currentReasoning,
-                        sequence: state.sequence,
-                        stepIndex: state.stepIndex,
-                        turnId: state.turnId,
-                    }));
-                    currentReasoning = "";
-                }
-                currentMessage += part.text;
-                await emitFn(createMessageAppendedEvent({
-                    messageDelta: part.text,
-                    messageSoFar: currentMessage,
-                    sequence: state.sequence,
-                    stepIndex: state.stepIndex,
-                    turnId: state.turnId,
-                }));
-                break;
-            case "tool-call":
-                toolCallIdsSeenInStream.add(part.toolCallId);
-                break;
-            case "tool-result": {
-                // Approval-resume: the AI SDK enqueues a previously-parked
-                // tool's result onto the parent stream before re-entering the
-                // LLM call. The tool-call itself was emitted on a prior step's
-                // stream, so it is absent here. Surface `action.result`
-                // inline so it precedes the message events that consume it.
-                if (toolCallIdsSeenInStream.has(part.toolCallId)) {
-                    break;
-                }
-                await flushCurrentMessage();
-                const inlineToolResult = part;
-                await emitFn(createActionResultEvent({
-                    result: createRuntimeToolResultFromStepResult(inlineToolResult),
-                    sequence: state.sequence,
-                    stepIndex: state.stepIndex,
-                    turnId: state.turnId,
-                }));
-                inlineActionResultCallIds.add(part.toolCallId);
-                // Match AI SDK's `createToolModelOutput` shape (json for non-strings,
-                // text for strings) so persisted history is shape-compatible.
-                const rawOutput = inlineToolResult.output;
-                inlineToolResultParts.push({
-                    type: "tool-result",
-                    toolCallId: inlineToolResult.toolCallId,
-                    toolName: inlineToolResult.toolName,
-                    output: typeof rawOutput === "string"
-                        ? { type: "text", value: rawOutput }
-                        : { type: "json", value: (rawOutput ?? null) },
-                });
-                break;
-            }
-            case "finish-step":
-                finishReason = normalizeAssistantStepFinishReason(part.finishReason);
-                break;
-            case "error":
-                // `part.error` is typed as `unknown` — AI SDK providers emit
-                // whatever the upstream service threw. Coerce through `toError`
-                // so plain-object shapes (structured-clone survivors, typed
-                // gateway payloads) keep their `message`, `name`, `stack`, and
-                // `cause` instead of degrading to `new Error("[object Object]")`.
-                streamError = toError(part.error);
-                break;
-            default:
-                break;
-        }
-    }
-    if (streamError !== undefined) {
-        throw streamError;
-    }
-    // Flush remaining reasoning.
-    if (currentReasoning.trim().length > 0) {
-        await emitFn(createReasoningCompletedEvent({
-            reasoning: currentReasoning,
-            sequence: state.sequence,
-            stepIndex: state.stepIndex,
-            turnId: state.turnId,
-        }));
-    }
-    // Flush remaining text.
-    if (currentMessage.length > 0) {
-        await emitFn(createMessageCompletedEvent({
-            finishReason,
-            message: currentMessage,
-            sequence: state.sequence,
-            stepIndex: state.stepIndex,
-            turnId: state.turnId,
-        }));
-    }
-    return { inlineActionResultCallIds, inlineToolResultParts };
-}
+import{toError}from"#shared/errors.js";import{createActionResultEvent,createMessageAppendedEvent,createMessageCompletedEvent,createMessageReceivedEvent,createReasoningAppendedEvent,createReasoningCompletedEvent,createSessionCompletedEvent,createSessionFailedEvent,createSessionStartedEvent,createSessionWaitingEvent,createStepFailedEvent,createStepStartedEvent,createTurnCompletedEvent,createTurnFailedEvent,createTurnStartedEvent}from"#protocol/message.js";import{createRuntimeToolResultFromStepResult}from"#harness/action-result-helpers.js";var HARNESS_EMISSION_STATE_KEY=`ash.harness.emission`,DEFAULT_EMISSION_STATE={sessionStarted:!1,sequence:0,stepIndex:0,turnId:``};function getHarnessEmissionState(e){return e.state?.[HARNESS_EMISSION_STATE_KEY]??DEFAULT_EMISSION_STATE}function isHarnessBetweenTurns(e){return getHarnessEmissionState(e).turnId===``}function setHarnessEmissionState(e,t){return{...e,state:{...e.state,[HARNESS_EMISSION_STATE_KEY]:t}}}async function emitTurnPreamble(e,t,n,r){let a=`turn_${n.sequence}`;return n.sessionStarted||await e(createSessionStartedEvent({runtime:r})),await e(createTurnStartedEvent({sequence:n.sequence,turnId:a})),t.message!==void 0&&await e(createMessageReceivedEvent({message:t.message,sequence:n.sequence,turnId:a})),{sessionStarted:!0,sequence:n.sequence,stepIndex:0,turnId:a}}async function emitStepStarted(e,t){await e(createStepStartedEvent({sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}))}async function emitStepAndTurnFailed(e,t,n){await e(createStepFailedEvent({...n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),await e(createTurnFailedEvent({...n,sequence:t.sequence,turnId:t.turnId}))}async function emitFailedStep(e,t,n){await emitStepAndTurnFailed(e,t,n),await e(createSessionFailedEvent(n))}async function emitRecoverableFailedTurn(e,t,n){return await emitStepAndTurnFailed(e,t,n),await e(createSessionWaitingEvent()),{sessionStarted:t.sessionStarted,sequence:t.sequence+1,stepIndex:0,turnId:``}}function advanceStep(e){return{...e,stepIndex:e.stepIndex+1}}async function emitTurnEpilogue(e,t,n){return await e(createTurnCompletedEvent({sequence:t.sequence,turnId:t.turnId})),n===`conversation`?await e(createSessionWaitingEvent()):await e(createSessionCompletedEvent()),{sessionStarted:t.sessionStarted,sequence:t.sequence+1,stepIndex:0,turnId:``}}function normalizeAssistantStepFinishReason(e){switch(e){case`content-filter`:case`error`:case`length`:case`stop`:case`tool-calls`:return e;default:return`other`}}async function emitStreamContent(i,o,s){let c=``,l=``,u=`stop`,d,f=new Set,p=new Set,m=[],flushCurrentMessage=async()=>{l.length!==0&&(await i(createMessageCompletedEvent({finishReason:`tool-calls`,message:l,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId})),l=``)};for await(let r of s)if(d===void 0)switch(r.type){case`reasoning-delta`:c+=r.text,await i(createReasoningAppendedEvent({reasoningDelta:r.text,reasoningSoFar:c,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId}));break;case`text-delta`:c.trim().length>0&&(await i(createReasoningCompletedEvent({reasoning:c,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId})),c=``),l+=r.text,await i(createMessageAppendedEvent({messageDelta:r.text,messageSoFar:l,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId}));break;case`tool-call`:f.add(r.toolCallId);break;case`tool-result`:{if(f.has(r.toolCallId))break;await flushCurrentMessage();let e=r;await i(createActionResultEvent({result:createRuntimeToolResultFromStepResult(e),sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId})),p.add(r.toolCallId);let n=e.output;m.push({type:`tool-result`,toolCallId:e.toolCallId,toolName:e.toolName,output:typeof n==`string`?{type:`text`,value:n}:{type:`json`,value:n??null}});break}case`finish-step`:u=normalizeAssistantStepFinishReason(r.finishReason);break;case`error`:d=toError(r.error);break;default:break}if(d!==void 0)throw d;return c.trim().length>0&&await i(createReasoningCompletedEvent({reasoning:c,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId})),l.length>0&&await i(createMessageCompletedEvent({finishReason:u,message:l,sequence:o.sequence,stepIndex:o.stepIndex,turnId:o.turnId})),{inlineActionResultCallIds:p,inlineToolResultParts:m}}export{advanceStep,emitFailedStep,emitRecoverableFailedTurn,emitStepStarted,emitStreamContent,emitTurnEpilogue,emitTurnPreamble,getHarnessEmissionState,isHarnessBetweenTurns,normalizeAssistantStepFinishReason,setHarnessEmissionState};

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

@@ -1 +1 @@
-export {};
+export{};

package/dist/src/harness/input-extraction.js

@@ -1,62 +1 @@
-import { ASK_QUESTION_TOOL_NAME } from "#runtime/framework-tools/ask-question.js";
-import { createRuntimeToolCallActionFromToolCall } from "#harness/input-requests.js";
-/**
- * Extracts question input requests from tool calls that target the
- * `ask_question` framework tool.
- */
-export function extractQuestionInputRequests(input) {
-    const requests = [];
-    for (const toolCall of input.toolCalls) {
-        if (toolCall.toolName !== ASK_QUESTION_TOOL_NAME) {
-            continue;
-        }
-        if (input.excludedCallIds.has(toolCall.toolCallId)) {
-            continue;
-        }
-        const action = createRuntimeToolCallActionFromToolCall({ toolCall });
-        const toolInput = action.input;
-        const request = {
-            action,
-            display: "text",
-            prompt: String(toolInput.prompt),
-            requestId: action.callId,
-        };
-        if (toolInput.allowFreeform !== undefined) {
-            request.allowFreeform = toolInput.allowFreeform;
-        }
-        if (toolInput.options !== undefined) {
-            request.options = toolInput.options;
-            request.display = "select";
-        }
-        requests.push(request);
-    }
-    return requests;
-}
-/**
- * Extracts tool approval input requests from AI SDK content parts that
- * contain `tool-approval-request` entries.
- */
-export function extractToolApprovalInputRequests(input) {
-    const requests = [];
-    for (const part of input.content) {
-        if (part.type !== "tool-approval-request") {
-            continue;
-        }
-        const approvalRequest = part;
-        const action = createRuntimeToolCallActionFromToolCall({
-            toolCall: approvalRequest.toolCall,
-        });
-        requests.push({
-            action,
-            allowFreeform: false,
-            display: "confirmation",
-            options: [
-                { id: "approve", label: "Yes" },
-                { id: "deny", label: "No" },
-            ],
-            prompt: `Approve tool call: ${approvalRequest.toolCall.toolName}`,
-            requestId: approvalRequest.approvalId,
-        });
-    }
-    return requests;
-}
+import{createRuntimeToolCallActionFromToolCall}from"#harness/input-requests.js";import{ASK_QUESTION_TOOL_NAME}from"#runtime/framework-tools/ask-question.js";function extractQuestionInputRequests(t){let n=[];for(let r of t.toolCalls){if(r.toolName!==ASK_QUESTION_TOOL_NAME||t.excludedCallIds.has(r.toolCallId))continue;let i=createRuntimeToolCallActionFromToolCall({toolCall:r}),a=i.input,o={action:i,display:`text`,prompt:String(a.prompt),requestId:i.callId};a.allowFreeform!==void 0&&(o.allowFreeform=a.allowFreeform),a.options!==void 0&&(o.options=a.options,o.display=`select`),n.push(o)}return n}function extractToolApprovalInputRequests(e){let t=[];for(let n of e.content){if(n.type!==`tool-approval-request`)continue;let e=n,r=createRuntimeToolCallActionFromToolCall({toolCall:e.toolCall});t.push({action:r,allowFreeform:!1,display:`confirmation`,options:[{id:`approve`,label:`Yes`},{id:`deny`,label:`No`}],prompt:`Approve tool call: ${e.toolCall.toolName}`,requestId:e.approvalId})}return t}export{extractQuestionInputRequests,extractToolApprovalInputRequests};