experimental-ash 0.26.0 → 0.28.0

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

@@ -1,306 +1 @@
-import { parseJsonObject } from "#shared/json.js";
-import { coalesceTurnInputs } from "#harness/messages.js";
-const PENDING_INPUT_BATCH_KEY = "ash.runtime.pendingInputBatch";
-const APPROVED_TOOLS_KEY = "ash.runtime.hitl.approvedTools";
-const DEFERRED_STEP_INPUT_KEY = "ash.runtime.deferredStepInput";
-const IGNORED_INPUT_REASON = "Ignored because the user continued without responding.";
-/**
- * Returns true when the step input carries user-facing turn input.
- */
-export function hasStepInput(input) {
-    if (input === undefined) {
-        return false;
-    }
-    return input.message !== undefined || (input.inputResponses?.length ?? 0) > 0;
-}
-// ---------------------------------------------------------------------------
-// Deferred step input
-// ---------------------------------------------------------------------------
-/**
- * Merges any queued follow-up input into the current step input and clears it
- * from session state.
- *
- * Used when the harness has to process a pending tool-approval response first
- * and defer the user's new message to the next internal model step.
- */
-export function consumeDeferredStepInput(input) {
-    const deferredInput = getDeferredStepInput(input.session);
-    if (deferredInput === undefined) {
-        return input;
-    }
-    const session = clearDeferredStepInput(input.session);
-    if (input.input === undefined) {
-        return {
-            input: deferredInput,
-            session,
-        };
-    }
-    return {
-        input: coalesceTurnInputs(deferredInput, input.input),
-        session,
-    };
-}
-/**
- * Returns true when the session carries queued follow-up input for the next
- * internal harness step.
- */
-export function hasDeferredStepInput(session) {
-    return getDeferredStepInput(session) !== undefined;
-}
-// ---------------------------------------------------------------------------
-// Pending input resolution
-// ---------------------------------------------------------------------------
-/**
- * Resolves pending input at the start of a harness step.
- *
- * When the pending batch contains tool-approval requests and the step input
- * also carries a follow-up user message, the message is deferred to the next
- * internal harness step rather than appended to the current turn. This is
- * necessary because AI SDK cannot process tool-approval responses and a new
- * user message in the same request -- the approval must be resolved in
- * isolation first, and the user message replayed on the subsequent step via
- * {@link consumeDeferredStepInput}.
- */
-export function resolvePendingInput(input) {
-    const { stepInput } = input;
-    let session = input.session;
-    const baseHistory = [...(input.history ?? session.history)];
-    const pendingBatch = getPendingInputBatch(session);
-    // No pending batch -- pass through to the model call.
-    if (pendingBatch === undefined) {
-        return { outcome: "continue", messages: baseHistory, session };
-    }
-    // Pending batch exists -- only resolve if we have actual responses.
-    const responses = stepInput?.inputResponses ?? [];
-    if (responses.length === 0 && stepInput?.message === undefined) {
-        return { outcome: "unresolved", messages: baseHistory, session };
-    }
-    if (responses.length === 0 && stepInput?.message !== undefined) {
-        // A follow-up message arrived but no explicit responses. Auto-deny
-        // all pending requests so the model can continue, and either defer
-        // the message (for approval batches) or pass it through.
-        const toolParts = buildToolResponseParts(pendingBatch, []);
-        const messages = [...baseHistory, ...pendingBatch.responseMessages];
-        if (toolParts.length > 0) {
-            messages.push({ content: toolParts, role: "tool" });
-        }
-        session = clearPendingInputBatch(session);
-        if (pendingBatch.requests.some((request) => isApprovalRequest(request))) {
-            session = queueDeferredStepInput(session, {
-                message: stepInput.message,
-            });
-            return { deferredMessage: true, outcome: "resolved", messages, session };
-        }
-        return { outcome: "resolved", messages, session };
-    }
-    // Record approved tools before clearing the batch.
-    session = recordApprovedTools({
-        pendingBatch,
-        resolveApprovalKey: input.resolveApprovalKey,
-        responses,
-        session,
-    });
-    // Build tool result messages from responses.
-    const toolParts = buildToolResponseParts(pendingBatch, responses);
-    const messages = [...baseHistory, ...pendingBatch.responseMessages];
-    if (toolParts.length > 0) {
-        messages.push({ content: toolParts, role: "tool" });
-    }
-    session = clearPendingInputBatch(session);
-    // AI SDK cannot process tool-approval responses and a new user message
-    // in the same request. Defer the message so the approval is resolved in
-    // isolation; `consumeDeferredStepInput` replays it on the next step.
-    if (stepInput?.message !== undefined &&
-        pendingBatch.requests.some((request) => isApprovalRequest(request))) {
-        session = queueDeferredStepInput(session, {
-            message: stepInput.message,
-        });
-        return { deferredMessage: true, outcome: "resolved", messages, session };
-    }
-    return { outcome: "resolved", messages, session };
-}
-// ---------------------------------------------------------------------------
-// Pending batch management
-// ---------------------------------------------------------------------------
-/**
- * Returns true when the session is parked on a pending HITL input batch
- * (tool approvals or `ask_question` prompts).
- */
-export function hasPendingInputBatch(session) {
-    return getPendingInputBatch(session) !== undefined;
-}
-function getPendingInputBatch(session) {
-    const value = session.state?.[PENDING_INPUT_BATCH_KEY];
-    if (typeof value !== "object" || value === null) {
-        return undefined;
-    }
-    const batch = value;
-    if (!Array.isArray(batch.requests) || !Array.isArray(batch.responseMessages)) {
-        return undefined;
-    }
-    return batch;
-}
-/**
- * Stores one pending HITL batch on the session until the user responds.
- */
-export function setPendingInputBatch(input) {
-    const state = { ...input.session.state };
-    state[PENDING_INPUT_BATCH_KEY] = {
-        requests: [...input.requests],
-        responseMessages: [...input.responseMessages],
-    };
-    return { ...input.session, state };
-}
-function clearPendingInputBatch(session) {
-    if (session.state?.[PENDING_INPUT_BATCH_KEY] === undefined) {
-        return session;
-    }
-    const state = { ...session.state };
-    delete state[PENDING_INPUT_BATCH_KEY];
-    return { ...session, state: Object.keys(state).length > 0 ? state : undefined };
-}
-// ---------------------------------------------------------------------------
-// Deferred step input state
-// ---------------------------------------------------------------------------
-function getDeferredStepInput(session) {
-    return session.state?.[DEFERRED_STEP_INPUT_KEY];
-}
-function queueDeferredStepInput(session, input) {
-    const existing = getDeferredStepInput(session);
-    const deferredInput = existing === undefined ? input : coalesceTurnInputs(existing, input);
-    const state = { ...session.state };
-    state[DEFERRED_STEP_INPUT_KEY] = deferredInput;
-    return {
-        ...session,
-        state,
-    };
-}
-function clearDeferredStepInput(session) {
-    if (session.state?.[DEFERRED_STEP_INPUT_KEY] === undefined) {
-        return session;
-    }
-    const state = { ...session.state };
-    delete state[DEFERRED_STEP_INPUT_KEY];
-    return {
-        ...session,
-        state: Object.keys(state).length > 0 ? state : undefined,
-    };
-}
-// ---------------------------------------------------------------------------
-// Approval tracking
-// ---------------------------------------------------------------------------
-/**
- * Returns the set of tool names that have been approved at least once
- * during this session.
- */
-export function getApprovedTools(session) {
-    const value = session.state?.[APPROVED_TOOLS_KEY];
-    if (!Array.isArray(value)) {
-        return new Set();
-    }
-    return new Set(value);
-}
-/**
- * Resolves the approval key for a request. When a `resolveApprovalKey`
- * function is provided and returns a string, that compound key is recorded
- * instead of the bare tool name.
- */
-function recordApprovedTools(input) {
-    const approvedIds = new Set(input.responses.filter((r) => r.optionId === "approve").map((r) => r.requestId));
-    const newKeys = input.pendingBatch.requests
-        .filter((r) => approvedIds.has(r.requestId))
-        .map((r) => input.resolveApprovalKey?.(r) ?? r.action.toolName);
-    if (newKeys.length === 0) {
-        return input.session;
-    }
-    const existing = getApprovedTools(input.session);
-    const combined = [...new Set([...existing, ...newKeys])];
-    const state = { ...input.session.state };
-    state[APPROVED_TOOLS_KEY] = combined;
-    return { ...input.session, state };
-}
-// ---------------------------------------------------------------------------
-// Tool response building
-// ---------------------------------------------------------------------------
-function buildToolResponseParts(batch, responses) {
-    const responseMap = new Map(responses.map((r) => [r.requestId, r]));
-    const parts = [];
-    for (const request of batch.requests) {
-        parts.push(...buildToolResponsePartsForRequest(request, responseMap.get(request.requestId)));
-    }
-    return parts;
-}
-function buildToolResponsePartsForRequest(request, response) {
-    if (isApprovalRequest(request)) {
-        const approved = response?.optionId === "approve";
-        const reason = response === undefined ? IGNORED_INPUT_REASON : undefined;
-        const parts = [
-            {
-                approvalId: request.requestId,
-                approved,
-                reason,
-                type: "tool-approval-response",
-            },
-        ];
-        /*
-         * On denial (explicit "deny" or auto-deny when the user continues
-         * without responding), splice in the matching `execution-denied`
-         * tool-result. AI SDK's `streamText` synthesizes this for the
-         * current turn's `initialResponseMessages`, but that synthesis is
-         * gated on the input messages' last entry being a tool message —
-         * on subsequent turns (when a new user message is the tail of
-         * history) the synthesis is skipped, and the persisted
-         * `tool-approval-response` is stripped during provider prompt
-         * conversion. Without an own `tool-result` in history, the prior
-         * `tool_use` block replays unmatched and some providers reject
-         * the request with 400.
-         */
-        if (!approved) {
-            parts.push({
-                output: { type: "execution-denied", reason },
-                toolCallId: request.action.callId,
-                toolName: request.action.toolName,
-                type: "tool-result",
-            });
-        }
-        return parts;
-    }
-    return [
-        {
-            output: {
-                type: "json",
-                value: response !== undefined
-                    ? { optionId: response.optionId, text: response.text, status: "answered" }
-                    : { status: "ignored" },
-            },
-            toolCallId: request.action.callId,
-            toolName: request.action.toolName,
-            type: "tool-result",
-        },
-    ];
-}
-function isApprovalRequest(request) {
-    return (request.options?.length === 2 &&
-        request.options[0]?.id === "approve" &&
-        request.options[1]?.id === "deny");
-}
-// ---------------------------------------------------------------------------
-// Tool call helpers
-// ---------------------------------------------------------------------------
-/**
- * Creates a runtime tool-call action shape from an AI SDK tool call.
- */
-export function createRuntimeToolCallActionFromToolCall(input) {
-    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);
-}
+import{parseJsonObject}from"#shared/json.js";import{coalesceTurnInputs}from"#harness/messages.js";var PENDING_INPUT_BATCH_KEY=`ash.runtime.pendingInputBatch`,APPROVED_TOOLS_KEY=`ash.runtime.hitl.approvedTools`,DEFERRED_STEP_INPUT_KEY=`ash.runtime.deferredStepInput`,IGNORED_INPUT_REASON=`Ignored because the user continued without responding.`;function hasStepInput(e){return e===void 0?!1:e.message!==void 0||(e.inputResponses?.length??0)>0}function consumeDeferredStepInput(e){let n=getDeferredStepInput(e.session);if(n===void 0)return e;let r=clearDeferredStepInput(e.session);return e.input===void 0?{input:n,session:r}:{input:coalesceTurnInputs(n,e.input),session:r}}function hasDeferredStepInput(e){return getDeferredStepInput(e)!==void 0}function resolvePendingInput(e){let{stepInput:t}=e,n=e.session,r=[...e.history??n.history],i=getPendingInputBatch(n);if(i===void 0)return{outcome:`continue`,messages:r,session:n};let a=t?.inputResponses??[];if(a.length===0&&t?.message===void 0)return{outcome:`unresolved`,messages:r,session:n};if(a.length===0&&t?.message!==void 0){let e=buildToolResponseParts(i,[]),a=[...r,...i.responseMessages];return e.length>0&&a.push({content:e,role:`tool`}),n=clearPendingInputBatch(n),i.requests.some(e=>isApprovalRequest(e))?(n=queueDeferredStepInput(n,{message:t.message}),{deferredMessage:!0,outcome:`resolved`,messages:a,session:n}):{outcome:`resolved`,messages:a,session:n}}n=recordApprovedTools({pendingBatch:i,resolveApprovalKey:e.resolveApprovalKey,responses:a,session:n});let o=buildToolResponseParts(i,a),s=[...r,...i.responseMessages];return o.length>0&&s.push({content:o,role:`tool`}),n=clearPendingInputBatch(n),t?.message!==void 0&&i.requests.some(e=>isApprovalRequest(e))?(n=queueDeferredStepInput(n,{message:t.message}),{deferredMessage:!0,outcome:`resolved`,messages:s,session:n}):{outcome:`resolved`,messages:s,session:n}}function hasPendingInputBatch(e){return getPendingInputBatch(e)!==void 0}function getPendingInputBatch(e){let t=e.state?.[PENDING_INPUT_BATCH_KEY];if(typeof t!=`object`||!t)return;let r=t;if(!(!Array.isArray(r.requests)||!Array.isArray(r.responseMessages)))return r}function setPendingInputBatch(e){let t={...e.session.state};return t[PENDING_INPUT_BATCH_KEY]={requests:[...e.requests],responseMessages:[...e.responseMessages]},{...e.session,state:t}}function clearPendingInputBatch(e){if(e.state?.[PENDING_INPUT_BATCH_KEY]===void 0)return e;let t={...e.state};return delete t[PENDING_INPUT_BATCH_KEY],{...e,state:Object.keys(t).length>0?t:void 0}}function getDeferredStepInput(e){return e.state?.[DEFERRED_STEP_INPUT_KEY]}function queueDeferredStepInput(e,n){let r=getDeferredStepInput(e),a=r===void 0?n:coalesceTurnInputs(r,n),o={...e.state};return o[DEFERRED_STEP_INPUT_KEY]=a,{...e,state:o}}function clearDeferredStepInput(e){if(e.state?.[DEFERRED_STEP_INPUT_KEY]===void 0)return e;let t={...e.state};return delete t[DEFERRED_STEP_INPUT_KEY],{...e,state:Object.keys(t).length>0?t:void 0}}function getApprovedTools(e){let t=e.state?.[APPROVED_TOOLS_KEY];return Array.isArray(t)?new Set(t):new Set}function recordApprovedTools(e){let t=new Set(e.responses.filter(e=>e.optionId===`approve`).map(e=>e.requestId)),n=e.pendingBatch.requests.filter(e=>t.has(e.requestId)).map(t=>e.resolveApprovalKey?.(t)??t.action.toolName);if(n.length===0)return e.session;let i=getApprovedTools(e.session),a=[...new Set([...i,...n])],o={...e.session.state};return o[APPROVED_TOOLS_KEY]=a,{...e.session,state:o}}function buildToolResponseParts(e,t){let n=new Map(t.map(e=>[e.requestId,e])),r=[];for(let t of e.requests)r.push(...buildToolResponsePartsForRequest(t,n.get(t.requestId)));return r}function buildToolResponsePartsForRequest(e,t){if(isApprovalRequest(e)){let n=t?.optionId===`approve`,r=t===void 0?IGNORED_INPUT_REASON:void 0,i=[{approvalId:e.requestId,approved:n,reason:r,type:`tool-approval-response`}];return n||i.push({output:{type:`execution-denied`,reason:r},toolCallId:e.action.callId,toolName:e.action.toolName,type:`tool-result`}),i}return[{output:{type:`json`,value:t===void 0?{status:`ignored`}:{optionId:t.optionId,text:t.text,status:`answered`}},toolCallId:e.action.callId,toolName:e.action.toolName,type:`tool-result`}]}function isApprovalRequest(e){return e.options?.length===2&&e.options[0]?.id===`approve`&&e.options[1]?.id===`deny`}function createRuntimeToolCallActionFromToolCall(e){return{callId:e.toolCall.toolCallId,input:resolveToolCallInputObject(e.toolCall.input),kind:`tool-call`,toolName:e.toolCall.toolName}}function resolveToolCallInputObject(t){return t==null?{}:parseJsonObject(t)}export{consumeDeferredStepInput,createRuntimeToolCallActionFromToolCall,getApprovedTools,hasDeferredStepInput,hasPendingInputBatch,hasStepInput,resolvePendingInput,setPendingInputBatch};

package/dist/src/harness/instrumentation-config.js

@@ -1,42 +1 @@
-/**
- * Process-global store for the authored instrumentation config.
- *
- * Populated at server startup by the generated Nitro instrumentation plugin
- * when the user's `agent/instrumentation.ts` has a default export produced
- * by `defineInstrumentation()`. The harness reads from this at turn time
- * to decide whether telemetry is enabled and which settings to pass to the
- * AI SDK.
- *
- * Rooted on `globalThis` so the generated Nitro instrumentation plugin
- * (which Nitro keeps external by `file://` URL) and the bundled harness
- * chunk (which Nitro inlines via the package's `#harness/*` import alias)
- * share one source of truth, even though they resolve to two distinct ESM
- * module instances. See `context/key.ts` and
- * `runtime/sessions/runtime-session.ts` for the established pattern.
- */
-const INSTRUMENTATION_CONFIG_GLOBAL_KEY = Symbol.for("experimental-ash.harness-instrumentation-config");
-const globalContainer = globalThis;
-/**
- * Registers the authored instrumentation config and invokes its `setup`
- * callback with the resolved agent name.
- *
- * Called once by the generated instrumentation Nitro plugin at server
- * startup. Subsequent calls overwrite the previous value.
- *
- * @internal — not part of the public API.
- */
-export function registerInstrumentationConfig(config, context) {
-    if (config.setup !== undefined) {
-        config.setup(context);
-    }
-    globalContainer[INSTRUMENTATION_CONFIG_GLOBAL_KEY] = config;
-}
-/**
- * Returns the registered instrumentation config, or `undefined` when no
- * `defineInstrumentation` export was provided.
- *
- * @internal — not part of the public API.
- */
-export function getInstrumentationConfig() {
-    return globalContainer[INSTRUMENTATION_CONFIG_GLOBAL_KEY];
-}
+var INSTRUMENTATION_CONFIG_GLOBAL_KEY=Symbol.for(`experimental-ash.harness-instrumentation-config`),globalContainer=globalThis;function registerInstrumentationConfig(e,t){e.setup!==void 0&&e.setup(t),globalContainer[INSTRUMENTATION_CONFIG_GLOBAL_KEY]=e}function getInstrumentationConfig(){return globalContainer[INSTRUMENTATION_CONFIG_GLOBAL_KEY]}export{getInstrumentationConfig,registerInstrumentationConfig};

package/dist/src/harness/messages.js

@@ -1,144 +1 @@
-/**
- * Merges two {@link StepInput} values into one.
- *
- * Used by the harness to coalesce deferred step input with the current
- * turn's input, and by the execution layer after calling `onDeliver`
- * for each queued delivery payload.
- */
-export function coalesceTurnInputs(a, b) {
-    const inputResponses = coalesceInputResponses({
-        a: a.inputResponses,
-        b: b.inputResponses,
-    });
-    const message = coalesceMessage({
-        a: a.message,
-        b: b.message,
-    });
-    const modelContext = coalesceModelContext({
-        a: a.modelContext,
-        b: b.modelContext,
-    });
-    const result = {};
-    if (inputResponses !== undefined) {
-        result.inputResponses = inputResponses;
-    }
-    if (message !== undefined) {
-        result.message = message;
-    }
-    if (modelContext !== undefined) {
-        result.modelContext = modelContext;
-    }
-    return result;
-}
-/**
- * Extracts the final visible assistant text from model response messages.
- *
- * Prefers text extracted from the last assistant message that contains visible
- * text. Falls back to the raw `text` property from the AI SDK result when no
- * assistant message contains text. Returns `null` when neither source contains
- * text.
- */
-export function resolveAssistantStepText(messages, fallback) {
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-        const message = messages[index];
-        if (message?.role !== "assistant") {
-            continue;
-        }
-        const text = extractMessageText(message);
-        if (text.length > 0) {
-            return text;
-        }
-    }
-    if (fallback !== undefined && fallback.length > 0) {
-        return fallback;
-    }
-    return null;
-}
-function extractMessageText(message) {
-    if (typeof message.content === "string") {
-        return message.content;
-    }
-    if (!Array.isArray(message.content)) {
-        return "";
-    }
-    return message.content
-        .flatMap((part) => {
-        if (typeof part === "string") {
-            return [part];
-        }
-        return "type" in part && part.type === "text" && typeof part.text === "string"
-            ? [part.text]
-            : [];
-    })
-        .join("");
-}
-function coalesceInputResponses(input) {
-    const a = input.a ?? [];
-    const b = input.b ?? [];
-    if (a.length === 0 && b.length === 0) {
-        return undefined;
-    }
-    return [...a, ...b];
-}
-function coalesceModelContext(input) {
-    const a = input.a ?? [];
-    const b = input.b ?? [];
-    if (a.length === 0 && b.length === 0) {
-        return undefined;
-    }
-    return [...a, ...b];
-}
-/**
- * Merges two optional turn messages into one.
- *
- * When both sides are strings, concatenates with a blank line. When
- * either side is a structured {@link UserContent} array, promotes both
- * to arrays and concatenates their parts so attachments carried on the
- * deferred or newer input are preserved end-to-end.
- */
-function coalesceMessage(input) {
-    if (input.a === undefined) {
-        return input.b;
-    }
-    if (input.b === undefined) {
-        return input.a;
-    }
-    if (typeof input.a === "string" && typeof input.b === "string") {
-        return `${input.a}\n\n${input.b}`;
-    }
-    const merged = [...toUserContentArray(input.a), ...toUserContentArray(input.b)];
-    return merged;
-}
-function toUserContentArray(value) {
-    if (typeof value === "string") {
-        return value.length > 0 ? [{ type: "text", text: value }] : [];
-    }
-    if (Array.isArray(value)) {
-        return [...value];
-    }
-    return [];
-}
-/**
- * Coalesces an array of deliver-like items into a single item by
- * collecting all payloads and keeping the most recent auth value.
- *
- * Used by the workflow runtime to batch follow-up deliveries that
- * arrived while a turn or subagent delegation was in progress. Each
- * payload is later passed to `onDeliver` individually so channel-
- * specific fields are never lost.
- */
-export function coalesceDeliveries(items) {
-    const [first, ...rest] = items;
-    if (first === undefined) {
-        throw new Error("Cannot coalesce an empty delivery batch.");
-    }
-    let auth = first.auth;
-    const payloads = [...first.payloads];
-    for (const item of rest) {
-        if (item.auth !== undefined) {
-            auth = item.auth;
-        }
-        payloads.push(...item.payloads);
-    }
-    return { ...first, auth, payloads };
-}
+function coalesceTurnInputs(e,t){let n=coalesceInputResponses({a:e.inputResponses,b:t.inputResponses}),r=coalesceMessage({a:e.message,b:t.message}),i=coalesceModelContext({a:e.modelContext,b:t.modelContext}),a={};return n!==void 0&&(a.inputResponses=n),r!==void 0&&(a.message=r),i!==void 0&&(a.modelContext=i),a}function resolveAssistantStepText(e,t){for(let t=e.length-1;t>=0;--t){let n=e[t];if(n?.role!==`assistant`)continue;let r=extractMessageText(n);if(r.length>0)return r}return t!==void 0&&t.length>0?t:null}function extractMessageText(e){return typeof e.content==`string`?e.content:Array.isArray(e.content)?e.content.flatMap(e=>typeof e==`string`?[e]:`type`in e&&e.type===`text`&&typeof e.text==`string`?[e.text]:[]).join(``):``}function coalesceInputResponses(e){let t=e.a??[],n=e.b??[];if(!(t.length===0&&n.length===0))return[...t,...n]}function coalesceModelContext(e){let t=e.a??[],n=e.b??[];if(!(t.length===0&&n.length===0))return[...t,...n]}function coalesceMessage(e){return e.a===void 0?e.b:e.b===void 0?e.a:typeof e.a==`string`&&typeof e.b==`string`?`${e.a}\n\n${e.b}`:[...toUserContentArray(e.a),...toUserContentArray(e.b)]}function toUserContentArray(e){return typeof e==`string`?e.length>0?[{type:`text`,text:e}]:[]:Array.isArray(e)?[...e]:[]}function coalesceDeliveries(e){let[t,...n]=e;if(t===void 0)throw Error(`Cannot coalesce an empty delivery batch.`);let r=t.auth,i=[...t.payloads];for(let e of n)e.auth!==void 0&&(r=e.auth),i.push(...e.payloads);return{...t,auth:r,payloads:i}}export{coalesceDeliveries,coalesceTurnInputs,resolveAssistantStepText};