experimental-ash 0.26.0 → 0.28.0

package/dist/src/execution/connection-auth-steps.js

@@ -1,338 +1 @@
-/**
- * Durable step boundaries that make up the interactive OAuth
- * await-authorization-and-splice flow.
- */
-import { buildAdapterContext } from "#channel/adapter-context.js";
-import { callAdapterEventHandler } from "#channel/adapter.js";
-import { contextStorage } from "#context/container.js";
-import { BundleKey, ChannelKey } from "#context/keys.js";
-import { getActiveRuntimeNode } from "#context/node.js";
-import { deserializeContext, serializeContext } from "#context/serialize.js";
-import { createConnectionAuthorizationCompletedEvent, createConnectionAuthorizationPendingEvent, createConnectionAuthorizationRequiredEvent, encodeMessageStreamEvent, timestampHandleMessageStreamEvent, } from "#protocol/message.js";
-import { isConnectionAuthorizationFailedError, isConnectionAuthorizationRequiredError, } from "#public/connections/errors.js";
-import { writeCachedToken } from "#runtime/connections/authorization-tokens.js";
-import { withConnectionPrincipalOverride } from "#runtime/connections/principal-context.js";
-import { principalKey, resolveConnectionPrincipal } from "#runtime/connections/principal.js";
-import { ConnectionRegistryImpl } from "#runtime/connections/registry.js";
-import { ConnectionRegistryKey, executeConnectionSearch, } from "#runtime/framework-tools/connection-search.js";
-import { isConnectionAuthorizationPlaceholder, PendingConnectionToolCallsKey, } from "#runtime/framework-tools/pending-connection-tool-calls.js";
-import { withDefaultAuthorizationInstructions } from "#execution/authorization-challenge-defaults.js";
-import { splicePendingToolResults } from "#execution/await-authorization-splice.js";
-/**
- * Runs one connection's `startAuthorization` callback inside a durable
- * step and emits the matching `connection.authorization_required`
- * event.
- *
- * Failures are captured as {@link StartAuthorizationStepResult.ok} =
- * `false` instead of thrown, so one connection's misconfigured
- * authorization does not abort the entire authorization cycle.
- */
-export async function startAuthorizationForConnectionStep(input) {
-    "use step";
-    const ctx = await deserializeContext(input.serializedContext);
-    const connection = findConnection(ctx, input.connectionName);
-    if (connection?.authorization?.startAuthorization === undefined) {
-        const reason = `Connection "${input.connectionName}" does not define startAuthorization.`;
-        await emitAuthorizationEvent(ctx, createConnectionAuthorizationCompletedEvent({
-            connectionName: input.connectionName,
-            outcome: "failed",
-            reason,
-            sequence: input.emissionState.sequence,
-            stepIndex: input.emissionState.stepIndex,
-            turnId: input.emissionState.turnId,
-        }), input.parentWritable);
-        return { ok: false, reason };
-    }
-    const description = connection.description ?? input.connectionName;
-    let principal;
-    let challenge;
-    let state;
-    try {
-        principal = resolveConnectionPrincipal(input.connectionName, connection.authorization, ctx);
-        const startResult = await connection.authorization.startAuthorization({
-            principal,
-            connection: { url: connection.url },
-            callbackUrl: input.webhookUrl,
-        });
-        challenge = withDefaultAuthorizationInstructions(startResult.challenge, input.connectionName);
-        state = startResult.state;
-    }
-    catch (err) {
-        const reason = err instanceof Error ? err.message : String(err);
-        await emitAuthorizationEvent(ctx, createConnectionAuthorizationCompletedEvent({
-            connectionName: input.connectionName,
-            outcome: "failed",
-            reason,
-            sequence: input.emissionState.sequence,
-            stepIndex: input.emissionState.stepIndex,
-            turnId: input.emissionState.turnId,
-        }), input.parentWritable);
-        return { ok: false, reason };
-    }
-    await emitAuthorizationEvent(ctx, createConnectionAuthorizationRequiredEvent({
-        authorization: challenge,
-        connectionName: input.connectionName,
-        description,
-        sequence: input.emissionState.sequence,
-        stepIndex: input.emissionState.stepIndex,
-        turnId: input.emissionState.turnId,
-        webhookUrl: input.webhookUrl,
-    }), input.parentWritable);
-    // Re-serialize ctx after the emit so any channel-state mutations
-    // the handler made (e.g. tracked Slack message ts) survive the
-    // step boundary into the matching `completeAuthorization` step.
-    return {
-        ok: true,
-        principal,
-        serializedContext: serializeContext(ctx),
-        state,
-    };
-}
-/**
- * Emits the `connection.authorization_pending` event once per
- * authorization cycle, after every `authorization_required` has been
- * written.
- */
-export async function emitConnectionAuthorizationPendingStep(input) {
-    "use step";
-    if (input.connectionNames.length === 0)
-        return;
-    const ctx = await deserializeContext(input.serializedContext);
-    await emitAuthorizationEvent(ctx, createConnectionAuthorizationPendingEvent({
-        connectionNames: input.connectionNames,
-        sequence: input.emissionState.sequence,
-        stepIndex: input.emissionState.stepIndex,
-        turnId: input.emissionState.turnId,
-    }), input.parentWritable);
-}
-/**
- * Runs one connection's `completeAuthorization` callback inside a
- * durable step and emits the matching
- * `connection.authorization_completed` event.
- *
- * Any error surfaces as a failure result with an appropriate
- * {@link ConnectionAuthorizationOutcome}. The workflow body continues
- * even when one connection fails, so the remainder of the authorization
- * cycle still resolves.
- */
-export async function completeAuthorizationForConnectionStep(input) {
-    "use step";
-    const ctx = await deserializeContext(input.serializedContext);
-    const connection = findConnection(ctx, input.connectionName);
-    if (connection?.authorization?.completeAuthorization === undefined) {
-        const reason = `Connection "${input.connectionName}" does not define completeAuthorization.`;
-        await emitAuthorizationEvent(ctx, createConnectionAuthorizationCompletedEvent({
-            connectionName: input.connectionName,
-            outcome: "failed",
-            reason,
-            sequence: input.emissionState.sequence,
-            stepIndex: input.emissionState.stepIndex,
-            turnId: input.emissionState.turnId,
-        }), input.parentWritable);
-        return { ok: false, reason, retryable: false };
-    }
-    try {
-        const token = await connection.authorization.completeAuthorization({
-            principal: input.principal,
-            connection: { url: connection.url },
-            request: input.request,
-            state: input.state,
-            callbackUrl: input.webhookUrl,
-        });
-        await emitAuthorizationEvent(ctx, createConnectionAuthorizationCompletedEvent({
-            connectionName: input.connectionName,
-            outcome: "authorized",
-            sequence: input.emissionState.sequence,
-            stepIndex: input.emissionState.stepIndex,
-            turnId: input.emissionState.turnId,
-        }), input.parentWritable);
-        return { ok: true, token };
-    }
-    catch (err) {
-        // Authorization failures are retryable by default: most
-        // `completeAuthorization` failures (network blip, IdP code
-        // already redeemed on replay, transient IdP error) resolve by
-        // starting a fresh auth flow, so the runtime treats every throw
-        // as retryable unless the author explicitly opts out with
-        // `ConnectionAuthorizationFailedError({ retryable: false })`
-        // (canonically: user clicked "Cancel" on the IdP consent screen).
-        const failed = isConnectionAuthorizationFailedError(err) ? err : null;
-        const retryable = failed?.retryable ?? true;
-        const reason = failed?.reason ?? (err instanceof Error ? err.message : String(err));
-        await emitAuthorizationEvent(ctx, createConnectionAuthorizationCompletedEvent({
-            connectionName: input.connectionName,
-            outcome: "failed",
-            reason,
-            sequence: input.emissionState.sequence,
-            stepIndex: input.emissionState.stepIndex,
-            turnId: input.emissionState.turnId,
-        }), input.parentWritable);
-        return { ok: false, reason, retryable };
-    }
-}
-/**
- * Retries every pending tool call whose connection has a freshly
- * minted token, splices the real results over the placeholder outputs
- * in history, clears the resolved cycle's context entries, and returns
- * the new session + serialized context.
- */
-export async function resolvePendingToolCallsStep(input) {
-    "use step";
-    const ctx = await deserializeContext(input.serializedContext);
-    const node = getActiveRuntimeNode(ctx);
-    const connections = node.agent?.connections ?? [];
-    const registry = new ConnectionRegistryImpl(connections);
-    ctx.setVirtualContext(ConnectionRegistryKey, registry);
-    for (const [connectionName, token] of Object.entries(input.tokens)) {
-        const principal = input.principals[connectionName];
-        if (principal === undefined) {
-            // Every successfully-completed connection must carry its
-            // resolved principal through the orchestrator; this is a
-            // framework invariant, not an authored error.
-            throw new Error(`Internal error: missing resolved principal for connection "${connectionName}".`);
-        }
-        writeCachedToken(ctx, connectionName, principalKey(principal), token);
-    }
-    const resolutions = {};
-    const resolvedSet = new Set(input.resolvedConnectionNames);
-    await contextStorage.run(ctx, () => withConnectionPrincipalOverride(ctx, input.principals, async () => {
-        for (const call of input.pendingCalls) {
-            const connectionNamesForCall = call.kind === "connection-execute" ? [call.connectionName] : call.connectionNames;
-            let failure;
-            for (const name of connectionNamesForCall) {
-                const entry = input.failedConnections[name];
-                if (entry !== undefined) {
-                    failure = { connectionName: name, ...entry };
-                    break;
-                }
-            }
-            if (failure !== undefined && call.kind === "connection-execute") {
-                // Retryable failures (for example `idp_code_reused`) are
-                // spliced as a soft `authorization_required` so the model can
-                // re-prompt for authorization on the next turn instead of
-                // treating the call as terminally failed.
-                resolutions[call.toolCallId] = failure.retryable
-                    ? {
-                        error: "authorization_required",
-                        retryable: true,
-                    }
-                    : {
-                        connectionName: failure.connectionName,
-                        error: "authorization_failed",
-                        message: failure.reason,
-                        retryable: false,
-                    };
-                continue;
-            }
-            const allResolved = connectionNamesForCall.every((name) => resolvedSet.has(name));
-            if (!allResolved && call.kind === "connection-execute") {
-                resolutions[call.toolCallId] = {
-                    error: "authorization_required",
-                    retryable: true,
-                };
-                continue;
-            }
-            try {
-                if (call.kind === "connection-execute") {
-                    const result = await registry
-                        .getClient(call.connectionName)
-                        .executeTool(call.toolName, call.args);
-                    resolutions[call.toolCallId] = normalizeToolResult(result);
-                }
-                else {
-                    const result = await executeConnectionSearch(call.args, { toolCallId: call.toolCallId });
-                    // `executeConnectionSearch` reports a still-unauthorized
-                    // connection by returning the placeholder sentinel rather
-                    // than throwing `Required`. Translate that to the same
-                    // soft-retryable error we splice for a thrown `Required` on
-                    // the single-tool retry path, otherwise the sentinel gets
-                    // JSON-stringified into history as an opaque
-                    // `{ __ashPlaceholder: "connection-authorization" }`.
-                    if (isConnectionAuthorizationPlaceholder(result)) {
-                        resolutions[call.toolCallId] = {
-                            error: "authorization_required",
-                            retryable: true,
-                        };
-                    }
-                    else {
-                        resolutions[call.toolCallId] = normalizeToolResult(result);
-                    }
-                }
-            }
-            catch (err) {
-                if (isConnectionAuthorizationRequiredError(err)) {
-                    // Connection is still gating on auth (token not yet
-                    // accepted by the server). Splice a soft-retryable error so
-                    // the model can prompt the user on the next turn instead of
-                    // deadlocking.
-                    resolutions[call.toolCallId] = {
-                        error: "authorization_required",
-                        retryable: true,
-                    };
-                    continue;
-                }
-                const message = err instanceof Error ? err.message : String(err);
-                resolutions[call.toolCallId] = {
-                    error: "tool_execution_failed",
-                    message,
-                    retryable: false,
-                };
-            }
-        }
-    }));
-    const splicedSession = splicePendingToolResults(input.session, resolutions);
-    // Clear authorization-cycle state for fully resolved calls so the
-    // next assistant step sees a clean slate. Unresolved pending calls
-    // stay on context so a subsequent cycle can retry them.
-    const remainingPending = input.pendingCalls.filter((call) => {
-        const names = call.kind === "connection-execute" ? [call.connectionName] : call.connectionNames;
-        return names.some((name) => !resolvedSet.has(name) && input.failedConnections[name] === undefined);
-    });
-    ctx.set(PendingConnectionToolCallsKey, remainingPending);
-    return {
-        serializedContext: serializeContext(ctx),
-        session: splicedSession,
-    };
-}
-function findConnection(ctx, connectionName) {
-    const bundle = ctx.get(BundleKey);
-    if (bundle === undefined)
-        return undefined;
-    const node = getActiveRuntimeNode(ctx);
-    const connections = node.agent?.connections ?? [];
-    return connections.find((c) => c.connectionName === connectionName);
-}
-async function emitAuthorizationEvent(ctx, event, parentWritable) {
-    const adapter = ctx.require(ChannelKey);
-    const adapterCtx = buildAdapterContext(adapter, ctx);
-    const finalEvent = await callAdapterEventHandler(adapter, event, adapterCtx);
-    // Pin any handler-driven channel-state mutations back onto ctx so
-    // they survive the durable step boundary when the caller
-    // re-serializes ctx (e.g. the Slack base layer's
-    // `connection.authorization_required` handler stores the public
-    // status message's ts on `__slackBase.pendingAuthMessageTs` so
-    // `connection.authorization_completed` can edit the same message
-    // in place a step later). Mirrors the post-emit pin in
-    // `workflow-steps.ts`.
-    ctx.set(ChannelKey, { ...adapter, state: { ...adapterCtx.state } });
-    const writer = parentWritable.getWriter();
-    try {
-        await writer.write(encodeMessageStreamEvent(timestampHandleMessageStreamEvent(finalEvent)));
-    }
-    finally {
-        writer.releaseLock();
-    }
-}
-function normalizeToolResult(result) {
-    if (result === undefined)
-        return null;
-    try {
-        return JSON.parse(JSON.stringify(result));
-    }
-    catch {
-        return {
-            error: "tool_result_not_serializable",
-            retryable: false,
-        };
-    }
-}
+import{createConnectionAuthorizationCompletedEvent,createConnectionAuthorizationPendingEvent,createConnectionAuthorizationRequiredEvent,encodeMessageStreamEvent,timestampHandleMessageStreamEvent}from"#protocol/message.js";import{contextStorage}from"#context/container.js";import{BundleKey,ChannelKey}from"#context/keys.js";import{callAdapterEventHandler}from"#channel/adapter.js";import{ConnectionRegistryImpl}from"#runtime/connections/registry.js";import{ConnectionRegistryKey,executeConnectionSearch}from"#runtime/framework-tools/connection-search.js";import{getActiveRuntimeNode}from"#context/node.js";import{PendingConnectionToolCallsKey,isConnectionAuthorizationPlaceholder}from"#runtime/framework-tools/pending-connection-tool-calls.js";import{buildAdapterContext}from"#channel/adapter-context.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError}from"#public/connections/errors.js";import{writeCachedToken}from"#runtime/connections/authorization-tokens.js";import{withConnectionPrincipalOverride}from"#runtime/connections/principal-context.js";import{principalKey,resolveConnectionPrincipal}from"#runtime/connections/principal.js";import{withDefaultAuthorizationInstructions}from"#execution/authorization-challenge-defaults.js";import{splicePendingToolResults}from"#execution/await-authorization-splice.js";async function startAuthorizationForConnectionStep(t){"use step";let r=await deserializeContext(t.serializedContext),i=findConnection(r,t.connectionName);if(i?.authorization?.startAuthorization===void 0){let n=`Connection "${t.connectionName}" does not define startAuthorization.`;return await emitAuthorizationEvent(r,createConnectionAuthorizationCompletedEvent({connectionName:t.connectionName,outcome:`failed`,reason:n,sequence:t.emissionState.sequence,stepIndex:t.emissionState.stepIndex,turnId:t.emissionState.turnId}),t.parentWritable),{ok:!1,reason:n}}let a=i.description??t.connectionName,o,s,c;try{o=resolveConnectionPrincipal(t.connectionName,i.authorization,r);let e=await i.authorization.startAuthorization({principal:o,connection:{url:i.url},callbackUrl:t.webhookUrl});s=withDefaultAuthorizationInstructions(e.challenge,t.connectionName),c=e.state}catch(n){let i=n instanceof Error?n.message:String(n);return await emitAuthorizationEvent(r,createConnectionAuthorizationCompletedEvent({connectionName:t.connectionName,outcome:`failed`,reason:i,sequence:t.emissionState.sequence,stepIndex:t.emissionState.stepIndex,turnId:t.emissionState.turnId}),t.parentWritable),{ok:!1,reason:i}}return await emitAuthorizationEvent(r,createConnectionAuthorizationRequiredEvent({authorization:s,connectionName:t.connectionName,description:a,sequence:t.emissionState.sequence,stepIndex:t.emissionState.stepIndex,turnId:t.emissionState.turnId,webhookUrl:t.webhookUrl}),t.parentWritable),{ok:!0,principal:o,serializedContext:serializeContext(r),state:c}}async function emitConnectionAuthorizationPendingStep(e){"use step";e.connectionNames.length!==0&&await emitAuthorizationEvent(await deserializeContext(e.serializedContext),createConnectionAuthorizationPendingEvent({connectionNames:e.connectionNames,sequence:e.emissionState.sequence,stepIndex:e.emissionState.stepIndex,turnId:e.emissionState.turnId}),e.parentWritable)}async function completeAuthorizationForConnectionStep(t){"use step";let n=await deserializeContext(t.serializedContext),r=findConnection(n,t.connectionName);if(r?.authorization?.completeAuthorization===void 0){let r=`Connection "${t.connectionName}" does not define completeAuthorization.`;return await emitAuthorizationEvent(n,createConnectionAuthorizationCompletedEvent({connectionName:t.connectionName,outcome:`failed`,reason:r,sequence:t.emissionState.sequence,stepIndex:t.emissionState.stepIndex,turnId:t.emissionState.turnId}),t.parentWritable),{ok:!1,reason:r,retryable:!1}}try{let i=await r.authorization.completeAuthorization({principal:t.principal,connection:{url:r.url},request:t.request,state:t.state,callbackUrl:t.webhookUrl});return await emitAuthorizationEvent(n,createConnectionAuthorizationCompletedEvent({connectionName:t.connectionName,outcome:`authorized`,sequence:t.emissionState.sequence,stepIndex:t.emissionState.stepIndex,turnId:t.emissionState.turnId}),t.parentWritable),{ok:!0,token:i}}catch(r){let i=isConnectionAuthorizationFailedError(r)?r:null,a=i?.retryable??!0,o=i?.reason??(r instanceof Error?r.message:String(r));return await emitAuthorizationEvent(n,createConnectionAuthorizationCompletedEvent({connectionName:t.connectionName,outcome:`failed`,reason:o,sequence:t.emissionState.sequence,stepIndex:t.emissionState.stepIndex,turnId:t.emissionState.turnId}),t.parentWritable),{ok:!1,reason:o,retryable:a}}}async function resolvePendingToolCallsStep(e){"use step";let t=await deserializeContext(e.serializedContext),n=new ConnectionRegistryImpl(getActiveRuntimeNode(t).agent?.connections??[]);t.setVirtualContext(ConnectionRegistryKey,n);for(let[n,r]of Object.entries(e.tokens)){let i=e.principals[n];if(i===void 0)throw Error(`Internal error: missing resolved principal for connection "${n}".`);writeCachedToken(t,n,principalKey(i),r)}let r={},i=new Set(e.resolvedConnectionNames);await contextStorage.run(t,()=>withConnectionPrincipalOverride(t,e.principals,async()=>{for(let t of e.pendingCalls){let a=t.kind===`connection-execute`?[t.connectionName]:t.connectionNames,o;for(let t of a){let n=e.failedConnections[t];if(n!==void 0){o={connectionName:t,...n};break}}if(o!==void 0&&t.kind===`connection-execute`){r[t.toolCallId]=o.retryable?{error:`authorization_required`,retryable:!0}:{connectionName:o.connectionName,error:`authorization_failed`,message:o.reason,retryable:!1};continue}if(!a.every(e=>i.has(e))&&t.kind===`connection-execute`){r[t.toolCallId]={error:`authorization_required`,retryable:!0};continue}try{if(t.kind===`connection-execute`){let e=await n.getClient(t.connectionName).executeTool(t.toolName,t.args);r[t.toolCallId]=normalizeToolResult(e)}else{let e=await executeConnectionSearch(t.args,{toolCallId:t.toolCallId});isConnectionAuthorizationPlaceholder(e)?r[t.toolCallId]={error:`authorization_required`,retryable:!0}:r[t.toolCallId]=normalizeToolResult(e)}}catch(e){if(isConnectionAuthorizationRequiredError(e)){r[t.toolCallId]={error:`authorization_required`,retryable:!0};continue}let n=e instanceof Error?e.message:String(e);r[t.toolCallId]={error:`tool_execution_failed`,message:n,retryable:!1}}}}));let o=splicePendingToolResults(e.session,r),s=e.pendingCalls.filter(t=>(t.kind===`connection-execute`?[t.connectionName]:t.connectionNames).some(t=>!i.has(t)&&e.failedConnections[t]===void 0));return t.set(PendingConnectionToolCallsKey,s),{serializedContext:serializeContext(t),session:o}}function findConnection(e,t){return e.get(BundleKey)===void 0?void 0:(getActiveRuntimeNode(e).agent?.connections??[]).find(e=>e.connectionName===t)}async function emitAuthorizationEvent(e,t,n){let a=e.require(ChannelKey),o=buildAdapterContext(a,e),l=await callAdapterEventHandler(a,t,o);e.set(ChannelKey,{...a,state:{...o.state}});let u=n.getWriter();try{await u.write(encodeMessageStreamEvent(timestampHandleMessageStreamEvent(l)))}finally{u.releaseLock()}}function normalizeToolResult(e){if(e===void 0)return null;try{return JSON.parse(JSON.stringify(e))}catch{return{error:`tool_result_not_serializable`,retryable:!1}}}export{completeAuthorizationForConnectionStep,emitConnectionAuthorizationPendingStep,resolvePendingToolCallsStep,startAuthorizationForConnectionStep};

package/dist/src/execution/node-step.js

@@ -1,146 +1 @@
-import { jsonSchema } from "ai";
-import { createToolLoopHarness } from "#harness/tool-loop.js";
-import { resolveInstalledPackageInfo } from "#internal/application/package.js";
-import { resolveRuntimeModelReference } from "#runtime/agent/resolve-model.js";
-import { findRegisteredRuntimeTool } from "#runtime/tools/registry.js";
-import { createToolCompactionHandler } from "#execution/tool-compaction.js";
-/**
- * Builds a harness step for one resolved runtime node using the execution-owned
- * tool, sandbox, and subagent wiring.
- */
-export function createExecutionNodeStep(input) {
-    const resolveModel = createRuntimeModelResolver(input.compiledArtifactsSource);
-    const tools = createNodeHarnessTools({ node: input.node });
-    const resolvedTools = collectResolvedTools(input.node);
-    const onCompaction = createToolCompactionHandler(resolvedTools);
-    const retentionPolicies = collectRetentionPolicies(resolvedTools);
-    return createToolLoopHarness({
-        capabilities: input.capabilities,
-        emit: input.emit,
-        mode: input.mode,
-        onCompaction,
-        resolveModel,
-        retentionPolicies,
-        runtimeIdentity: buildRuntimeIdentity(input.node),
-        tools,
-    });
-}
-/**
- * Builds a {@link RuntimeIdentity} from the resolved runtime agent node
- * and the current Ash package installation.
- */
-function buildRuntimeIdentity(node) {
-    const packageInfo = resolveInstalledPackageInfo();
-    const identity = {
-        agentId: node.turnAgent.id,
-        agentName: node.agent.config?.name,
-        ashVersion: packageInfo.version,
-        modelId: node.turnAgent.model.id,
-    };
-    const gitSha = process.env.VERCEL_GIT_COMMIT_SHA?.trim();
-    const gitBranch = process.env.VERCEL_GIT_COMMIT_REF?.trim();
-    const deployedAt = process.env.VERCEL_DEPLOYMENT_CREATED_AT?.trim();
-    if (gitSha || gitBranch || deployedAt) {
-        return {
-            ...identity,
-            build: {
-                deployedAt: deployedAt || undefined,
-                gitBranch: gitBranch || undefined,
-                gitSha: gitSha || undefined,
-            },
-        };
-    }
-    return identity;
-}
-function createRuntimeModelResolver(compiledArtifactsSource) {
-    return (modelReference) => resolveRuntimeModelReference(modelReference, {
-        compiledArtifactsSource,
-    });
-}
-/**
- * Collects the {@link ResolvedToolDefinition}s visible to one runtime node
- * for compaction-hook dispatch.
- */
-function collectResolvedTools(node) {
-    return [...node.toolRegistry.toolsByName.values()].map((registered) => registered.definition);
-}
-/**
- * Collects retention policies into a map keyed by tool name.
- *
- * Tools that declare `retentionPolicy: "keep"` or a function go into
- * the map. Tools that omit the field or set it to `"auto"` are skipped
- * — the pruning system falls back to the default placeholder for those.
- */
-function collectRetentionPolicies(tools) {
-    const policies = new Map();
-    for (const tool of tools) {
-        const policy = tool.retentionPolicy;
-        if (policy === undefined || policy === "auto") {
-            continue;
-        }
-        policies.set(tool.name, policy);
-    }
-    return policies;
-}
-/**
- * Resolves unified {@link HarnessToolDefinition}s from the node's registries.
- *
- * For authored tools: copies all lifecycle fields from the resolved definition.
- * For subagent tools: surfaces runtime-owned subagent-call metadata and leaves
- * execution to the runtime layer.
- * Tools without `execute` (provider-managed) get entries with schema but no execute.
- */
-function createNodeHarnessTools(input) {
-    const tools = new Map();
-    for (const tool of input.node.turnAgent.tools) {
-        const definition = resolveHarnessToolDefinition({
-            node: input.node,
-            tool,
-        });
-        if (definition !== null) {
-            tools.set(tool.name, definition);
-        }
-    }
-    return tools;
-}
-function resolveHarnessToolDefinition(input) {
-    if (input.tool.kind === "subagent") {
-        return {
-            description: input.tool.description ?? "",
-            inputSchema: jsonSchema(input.tool.inputSchema ?? {}),
-            name: input.tool.name,
-            runtimeAction: {
-                kind: "subagent-call",
-                nodeId: input.tool.nodeId,
-                subagentName: input.tool.name,
-            },
-        };
-    }
-    if (input.tool.kind === "remote") {
-        return {
-            description: input.tool.description ?? "",
-            inputSchema: jsonSchema(input.tool.inputSchema ?? {}),
-            name: input.tool.name,
-            runtimeAction: {
-                kind: "remote-agent-call",
-                nodeId: input.tool.nodeId,
-                remoteAgentName: input.tool.name,
-                subagentName: input.tool.name,
-            },
-        };
-    }
-    const registeredTool = findRegisteredRuntimeTool(input.node.toolRegistry, input.tool.name);
-    if (registeredTool === null) {
-        return null;
-    }
-    const def = registeredTool.definition;
-    return {
-        approvalKey: def.approvalKey,
-        description: def.description,
-        execute: def.execute,
-        inputSchema: def.inputStandardSchema ?? jsonSchema(def.inputSchema ?? {}),
-        name: def.name,
-        needsApproval: def.needsApproval,
-        toModelOutput: def.toModelOutput,
-    };
-}
+import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{jsonSchema}from"ai";import{createToolLoopHarness}from"#harness/tool-loop.js";import{resolveRuntimeModelReference}from"#runtime/agent/resolve-model.js";import{findRegisteredRuntimeTool}from"#runtime/tools/registry.js";import{createToolCompactionHandler}from"#execution/tool-compaction.js";function createExecutionNodeStep(e){let t=createRuntimeModelResolver(e.compiledArtifactsSource),r=createNodeHarnessTools({node:e.node}),i=collectResolvedTools(e.node),o=createToolCompactionHandler(i),s=collectRetentionPolicies(i);return createToolLoopHarness({capabilities:e.capabilities,emit:e.emit,mode:e.mode,onCompaction:o,resolveModel:t,retentionPolicies:s,runtimeIdentity:buildRuntimeIdentity(e.node),tools:r})}function buildRuntimeIdentity(t){let n=resolveInstalledPackageInfo(),r={agentId:t.turnAgent.id,agentName:t.agent.config?.name,ashVersion:n.version,modelId:t.turnAgent.model.id},i=process.env.VERCEL_GIT_COMMIT_SHA?.trim(),a=process.env.VERCEL_GIT_COMMIT_REF?.trim(),o=process.env.VERCEL_DEPLOYMENT_CREATED_AT?.trim();return i||a||o?{...r,build:{deployedAt:o||void 0,gitBranch:a||void 0,gitSha:i||void 0}}:r}function createRuntimeModelResolver(e){return t=>resolveRuntimeModelReference(t,{compiledArtifactsSource:e})}function collectResolvedTools(e){return[...e.toolRegistry.toolsByName.values()].map(e=>e.definition)}function collectRetentionPolicies(e){let t=new Map;for(let n of e){let e=n.retentionPolicy;e===void 0||e===`auto`||t.set(n.name,e)}return t}function createNodeHarnessTools(e){let t=new Map;for(let n of e.node.turnAgent.tools){let r=resolveHarnessToolDefinition({node:e.node,tool:n});r!==null&&t.set(n.name,r)}return t}function resolveHarnessToolDefinition(e){if(e.tool.kind===`subagent`)return{description:e.tool.description??``,inputSchema:jsonSchema(e.tool.inputSchema??{}),name:e.tool.name,runtimeAction:{kind:`subagent-call`,nodeId:e.tool.nodeId,subagentName:e.tool.name}};if(e.tool.kind===`remote`)return{description:e.tool.description??``,inputSchema:jsonSchema(e.tool.inputSchema??{}),name:e.tool.name,runtimeAction:{kind:`remote-agent-call`,nodeId:e.tool.nodeId,remoteAgentName:e.tool.name,subagentName:e.tool.name}};let n=findRegisteredRuntimeTool(e.node.toolRegistry,e.tool.name);if(n===null)return null;let r=n.definition;return{approvalKey:r.approvalKey,description:r.description,execute:r.execute,inputSchema:r.inputStandardSchema??jsonSchema(r.inputSchema??{}),name:r.name,needsApproval:r.needsApproval,toModelOutput:r.toModelOutput}}export{createExecutionNodeStep};

package/dist/src/execution/remote-agent-dispatch.js

@@ -1,79 +1 @@
-import { ASH_SESSION_ID_HEADER } from "#protocol/message.js";
-import { createAshCallbackRoutePath } from "#protocol/routes.js";
-import { formatSubagentInvocation } from "#execution/subagent-invocation.js";
-export async function startRemoteAgentSession(input) {
-    const callbackToken = input.session.continuationToken;
-    if (!callbackToken) {
-        throw new Error("Cannot dispatch remote agent without a parent continuation token.");
-    }
-    if (!input.callbackBaseUrl) {
-        throw new Error("Cannot dispatch remote agent without a callback base URL.");
-    }
-    const headers = await resolveRemoteAgentRequestHeaders(input.remote);
-    const response = await fetch(createRemoteAgentSessionUrl(input.remote), {
-        body: JSON.stringify({
-            callback: {
-                callId: input.action.callId,
-                subagentName: input.action.remoteAgentName,
-                token: callbackToken,
-                url: `${input.callbackBaseUrl}${createAshCallbackRoutePath(callbackToken)}`,
-            },
-            message: formatRemoteAgentCallInputMessage(input.action),
-            mode: "task",
-        }),
-        headers: {
-            "content-type": "application/json",
-            ...headers,
-        },
-        method: "POST",
-    });
-    if (!response.ok) {
-        throw new Error(`Remote agent "${input.action.remoteAgentName}" create-session request failed with HTTP ${response.status}.`);
-    }
-    const sessionIdFromHeader = response.headers.get(ASH_SESSION_ID_HEADER);
-    if (sessionIdFromHeader !== null && sessionIdFromHeader.length > 0) {
-        return sessionIdFromHeader;
-    }
-    try {
-        const body = (await response.json());
-        if (typeof body.sessionId === "string" && body.sessionId.length > 0) {
-            return body.sessionId;
-        }
-    }
-    catch {
-        // Fall through to the generic error below.
-    }
-    throw new Error(`Remote agent "${input.action.remoteAgentName}" create-session response did not include a session id.`);
-}
-export function resolveRemoteAgentForAction(input) {
-    const registered = input.registry.get(input.nodeId);
-    const definition = registered?.definition;
-    if (definition?.kind !== "remote") {
-        throw new Error(`Missing remote agent "${input.remoteAgentName}" in runtime registry.`);
-    }
-    return definition;
-}
-function createRemoteAgentSessionUrl(remote) {
-    return new URL(remote.path, `${trimTrailingSlash(remote.url)}/`).toString();
-}
-async function resolveRemoteAgentRequestHeaders(remote) {
-    const headers = {};
-    if (remote.headers !== undefined) {
-        Object.assign(headers, typeof remote.headers === "function" ? await remote.headers() : remote.headers);
-    }
-    if (remote.auth !== undefined) {
-        Object.assign(headers, (await remote.auth()).headers);
-    }
-    return headers;
-}
-function formatRemoteAgentCallInputMessage(input) {
-    const message = typeof input.input.message === "string" ? input.input.message : "";
-    return formatSubagentInvocation({
-        description: input.description,
-        message,
-        name: input.remoteAgentName,
-    }).message;
-}
-function trimTrailingSlash(value) {
-    return value.endsWith("/") ? value.slice(0, -1) : value;
-}
+import{createAshCallbackRoutePath}from"#protocol/routes.js";import{ASH_SESSION_ID_HEADER}from"#protocol/message.js";import{formatSubagentInvocation}from"#execution/subagent-invocation.js";async function startRemoteAgentSession(n){let r=n.session.continuationToken;if(!r)throw Error(`Cannot dispatch remote agent without a parent continuation token.`);if(!n.callbackBaseUrl)throw Error(`Cannot dispatch remote agent without a callback base URL.`);let i=await resolveRemoteAgentRequestHeaders(n.remote),a=await fetch(createRemoteAgentSessionUrl(n.remote),{body:JSON.stringify({callback:{callId:n.action.callId,subagentName:n.action.remoteAgentName,token:r,url:`${n.callbackBaseUrl}${createAshCallbackRoutePath(r)}`},message:formatRemoteAgentCallInputMessage(n.action),mode:`task`}),headers:{"content-type":`application/json`,...i},method:`POST`});if(!a.ok)throw Error(`Remote agent "${n.action.remoteAgentName}" create-session request failed with HTTP ${a.status}.`);let o=a.headers.get(ASH_SESSION_ID_HEADER);if(o!==null&&o.length>0)return o;try{let e=await a.json();if(typeof e.sessionId==`string`&&e.sessionId.length>0)return e.sessionId}catch{}throw Error(`Remote agent "${n.action.remoteAgentName}" create-session response did not include a session id.`)}function resolveRemoteAgentForAction(e){let t=e.registry.get(e.nodeId)?.definition;if(t?.kind!==`remote`)throw Error(`Missing remote agent "${e.remoteAgentName}" in runtime registry.`);return t}function createRemoteAgentSessionUrl(e){return new URL(e.path,`${trimTrailingSlash(e.url)}/`).toString()}async function resolveRemoteAgentRequestHeaders(e){let t={};return e.headers!==void 0&&Object.assign(t,typeof e.headers==`function`?await e.headers():e.headers),e.auth!==void 0&&Object.assign(t,(await e.auth()).headers),t}function formatRemoteAgentCallInputMessage(e){let t=typeof e.input.message==`string`?e.input.message:``;return formatSubagentInvocation({description:e.description,message:t,name:e.remoteAgentName}).message}function trimTrailingSlash(e){return e.endsWith(`/`)?e.slice(0,-1):e}export{resolveRemoteAgentForAction,startRemoteAgentSession};

package/dist/src/execution/runtime-context.js

@@ -1,26 +1 @@
-import { ContextContainer } from "#context/container.js";
-import { AuthKey, BundleKey, CapabilitiesKey, ChannelKey, ContinuationTokenKey, InitiatorAuthKey, ModeKey, ParentSessionKey, SessionCallbackKey, } from "#context/keys.js";
-/**
- * Builds the bootstrap {@link ContextContainer} for one run.
- */
-export function buildRunContext(input) {
-    const { bundle, run } = input;
-    const ctx = new ContextContainer();
-    const auth = run.auth;
-    ctx.set(BundleKey, bundle);
-    ctx.set(ChannelKey, run.adapter);
-    ctx.set(ContinuationTokenKey, run.continuationToken ?? "");
-    ctx.set(ModeKey, run.mode);
-    ctx.set(AuthKey, auth);
-    ctx.set(InitiatorAuthKey, run.initiatorAuth ?? auth);
-    if (run.capabilities !== undefined) {
-        ctx.set(CapabilitiesKey, run.capabilities);
-    }
-    if (run.callback !== undefined) {
-        ctx.set(SessionCallbackKey, run.callback);
-    }
-    if (run.parent !== undefined) {
-        ctx.set(ParentSessionKey, run.parent);
-    }
-    return ctx;
-}
+import{ContextContainer}from"#context/container.js";import{AuthKey,BundleKey,CapabilitiesKey,ChannelKey,ContinuationTokenKey,InitiatorAuthKey,ModeKey,ParentSessionKey,SessionCallbackKey}from"#context/keys.js";function buildRunContext(e){let{bundle:t,run:n}=e,r=new ContextContainer,i=n.auth;return r.set(BundleKey,t),r.set(ChannelKey,n.adapter),r.set(ContinuationTokenKey,n.continuationToken??``),r.set(ModeKey,n.mode),r.set(AuthKey,i),r.set(InitiatorAuthKey,n.initiatorAuth??i),n.capabilities!==void 0&&r.set(CapabilitiesKey,n.capabilities),n.callback!==void 0&&r.set(SessionCallbackKey,n.callback),n.parent!==void 0&&r.set(ParentSessionKey,n.parent),r}export{buildRunContext};

package/dist/src/execution/runtime-errors.js

@@ -1,19 +1 @@
-/**
- * Thrown by a {@link Runtime}'s `deliver` when no in-flight session
- * matches the continuation token. Callers using the resume-or-start
- * pattern (e.g. {@link createSendFn}) treat this as the signal to start
- * a fresh session.
- */
-export class RuntimeNoActiveSessionError extends Error {
-    code = "NO_ACTIVE_SESSION";
-    continuationToken;
-    constructor(continuationToken) {
-        super(`No active session for continuationToken "${continuationToken}".`);
-        this.name = "RuntimeNoActiveSessionError";
-        this.continuationToken = continuationToken;
-    }
-}
-/** Type guard for {@link RuntimeNoActiveSessionError}. */
-export function isRuntimeNoActiveSessionError(error) {
-    return error instanceof RuntimeNoActiveSessionError;
-}
+var RuntimeNoActiveSessionError=class extends Error{code=`NO_ACTIVE_SESSION`;continuationToken;constructor(e){super(`No active session for continuationToken "${e}".`),this.name=`RuntimeNoActiveSessionError`,this.continuationToken=e}};function isRuntimeNoActiveSessionError(e){return e instanceof RuntimeNoActiveSessionError}export{RuntimeNoActiveSessionError,isRuntimeNoActiveSessionError};