eve 0.30.7 → 0.31.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # eve
 
+## 0.31.0
+
+### Minor Changes
+
+- 40b09e6: Replace continuation-token session APIs with fixed, ID-addressed handles and consistent channel-local operations. This is a breaking migration across the following public surfaces:
+
+  - TypeScript clients now use `client.sessions.create(input)` to start a session and `client.sessions.attach(sessionId)` to obtain a fixed handle; `client.session(...)` and continuation-token client state are removed.
+  - Client, eval, frontend, fixed-session, and Slack message delivery now use positional `send(message, options)`. HITL replies use the separate `respond(inputResponses, options)` method, and `message` and `inputResponses` are mutually exclusive.
+  - Custom channels use `from(address)` for channel-local operations, top-level `resolveSession(address)` to resolve the current owner, `attachSession(sessionId)` for an immutable session handle, and `to(channel, target)` for cross-channel delivery.
+  - Slack message and interaction hooks expose `ctx.send`, `ctx.respond`, `ctx.cancel`, `ctx.compact`, `ctx.clear`, `ctx.reset`, and `ctx.resolveSession`. For generic events, the target is passed in each operation's options; `ctx.receive` and `resolveActiveSession` are removed.
+  - Schedule handlers replace `receive(channel, { message, target, auth })` with `to(channel, target).send(message, { auth })`.
+  - Channel event session identity moves to `ctx.session.id`, while `session.failed` includes `sessionId` in its event data.
+  - The eve HTTP API keeps `POST /eve/v1/session` for creation and `POST /eve/v1/session/:sessionId` for follow-ups. Clear, compact, and reset move from continuation-token body routes to `POST /eve/v1/session/:sessionId/{clear,compact,reset}`; cancel and streaming remain ID-addressed.
+  - Session message and control bodies no longer accept or return continuation tokens. Accepted asynchronous work returns HTTP `202`; no-active operation results omit `sessionId`, and inactive follow-ups return HTTP `409` with `code: "session_not_active"`, available as `ClientError.code`.
+  - Canonical eve `onMessage` hooks can no longer drop an otherwise authorized delivery by returning `null`.
+
+### Patch Changes
+
+- 2054b9f: Agent-messaging `<agents>` listings are now announced as framework-injected user-role notes instead of assistant messages appended to history. This fixes parent resume failures on models that reject assistant-final requests (e.g. `This model does not support assistant message prefill` from Claude via AI Gateway) after a persistent child parks, keeps the announcement append-only so provider prompt caches stay warm, and the agent-messaging system prompt now declares the `[Agents]` note as framework-injected.
+- 84c3dfc: Flush local development streaming response headers immediately so pending Workflow streams can be cancelled without accumulating listeners.
+- b7a2a14: Dev runtime snapshots now mount workspace dependency packages in place
+  instead of copying them. Only roots that host runtime-hydrated authored
+  source — the app root, extension mount roots, and tsconfig path-alias
+  targets — are still copied, matching how installed dependencies already
+  resolved. In monorepos this removes the largest per-generation copy: a
+  workspace-linked framework package (hundreds of files and tens of
+  megabytes per rebuild) no longer lands under
+  `.eve/dev-runtime/snapshots/`.
+
+## 0.30.8
+
+### Patch Changes
+
+- e6f4808: Add a single `eve add linear` flow that installs and configures both the Linear Channel and Linear MCP connection.
+- f51f866: Tools can now use async generators to stream preliminary output snapshots. eve publishes local snapshots as `action.partial` events before the final `action.result`, and the default client reducer exposes provisional output with `partial: true`.
+
 ## 0.30.7
 
 ### Patch Changes

package/README.md

@@ -27,7 +27,7 @@ Unless you configure stricter controls, eve agents may operate with permissive s
 - Durable message runs and follow-up turns
 - Inspectable compiled artifacts under `.eve/`
 - Per-agent sandbox with optional authored overrides
-- A stable HTTP protocol with explicit `continuationToken` and `sessionId` contracts
+- A stable HTTP protocol built around immutable session IDs
 - A runtime model that keeps channels, harnesses, and workflow execution separate
 
 ## Authored Directory
@@ -163,14 +163,13 @@ You do not need this section to author an eve agent — it documents the public
 
 eve's internal split is:
 
-- the **channel** normalizes inbound transport, applies auth and delivery policy, and owns `continuationToken`
+- the **channel** normalizes inbound transport, applies auth and delivery policy, and owns channel-local addresses
 - the **harness** does one unit of AI work and returns `{ session, next }`
 - the **runtime** persists state, follows `next`, streams events, and owns workflow primitives (`start()`, `resumeHook()`, `createHook()`, `getWritable()`)
 
-That split is why the public HTTP protocol separates two distinct identifiers:
-
-- `continuationToken` — channel-owned handle the caller uses to start the next user turn
-- `sessionId` — runtime-owned handle for streaming and inspection
+The public HTTP protocol exposes one immutable identifier: `sessionId`. Create a
+session explicitly, then use that ID for follow-up messages, controls, streaming,
+and inspection. Channel-local addresses remain behind authored channel APIs.
 
 ## Changelog
 

package/dist/src/acp/adapter.d.ts

@@ -1,16 +1,22 @@
 import { type AgentContext, type InitializeRequest, type InitializeResponse, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse } from "#compiled/@agentclientprotocol/sdk/index.js";
-import type { ClientOptions, SendTurnInput, SessionState } from "#client/types.js";
+import type { ClientOptions, SendTurnInput } from "#client/types.js";
 import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { InputResponse } from "#runtime/input/types.js";
 interface AdapterClientSession {
-    readonly state: SessionState;
-    send(input: SendTurnInput): Promise<AsyncIterable<HandleMessageStreamEvent>>;
+    send(message: SendTurnInput["message"]): Promise<AsyncIterable<HandleMessageStreamEvent>>;
+    respond(inputResponses: readonly InputResponse[]): Promise<AsyncIterable<HandleMessageStreamEvent>>;
     cancel(options?: {
         turnId?: string;
     }): Promise<unknown>;
     reset(): Promise<unknown>;
 }
 interface AdapterClient {
-    session(): AdapterClientSession;
+    readonly sessions: {
+        create(input: SendTurnInput): Promise<{
+            readonly response: AsyncIterable<HandleMessageStreamEvent>;
+            readonly session: AdapterClientSession;
+        }>;
+    };
 }
 /** Configuration for translating one ACP client connection to an eve server. */
 export interface EveAcpAdapterOptions {

package/dist/src/acp/adapter.js

@@ -1 +1 @@
-import{randomUUID}from"node:crypto";import{realpath}from"node:fs/promises";import{PROTOCOL_VERSION,RequestError,methods}from"#compiled/@agentclientprotocol/sdk/index.js";import{Client,ClientError}from"#client/index.js";const ANSWER_FIELD=`answer`,ERROR_CODE_EVE=-32002;var EveAcpAdapter=class{#e;#t;#n;#r=!1;#i=new Map;constructor(e){this.#t=e.eveVersion,this.#n=e.workspaceRoot,this.#e=e.client??new Client({auth:e.auth,headers:e.headers,host:e.serverUrl,preserveCompletedSessions:!0,redirect:`manual`})}initialize(e){return this.#r=e.clientCapabilities?.elicitation?.form!==void 0,{protocolVersion:PROTOCOL_VERSION,agentCapabilities:{loadSession:!1,promptCapabilities:{},sessionCapabilities:{close:{}}},agentInfo:{name:`eve`,title:`eve`,version:this.#t},authMethods:[]}}async newSession(t){if(t.mcpServers.length>0)throw unsupported(`Client-provided MCP servers are not supported by eve ACP mode.`);if((t.additionalDirectories?.length??0)>0)throw unsupported(`Additional workspace directories are not supported by eve ACP mode.`);if(this.#n!==void 0){let e=await normalizedRealpath(t.cwd,`session/new.cwd`),n=await normalizedRealpath(this.#n,`the eve application root`);if(e!==n)throw RequestError.invalidParams({cwd:t.cwd,workspaceRoot:n},`ACP cwd must be the eve application root`)}let n=randomUUID();return this.#i.set(n,{client:this.#e.session(),tools:new Map}),{sessionId:n}}async prompt(e,t,n){let i=this.#s(e.sessionId);if(i.active!==void 0)throw new RequestError(-32001,`ACP session ${e.sessionId} already has an active prompt.`);let a=promptContent(e);i.tools.clear();let o=Promise.withResolvers(),s={cancelRequested:!1,protocolCancelled:!1,outboundController:new AbortController,settled:o.promise,resolveSettled:o.resolve};i.active=s;let onProtocolCancel=()=>{s.protocolCancelled=!0,this.#o(i).catch(()=>void 0)};n.aborted?onProtocolCancel():n.addEventListener(`abort`,onProtocolCancel,{once:!0});try{if(s.protocolCancelled)throw RequestError.requestCancelled({sessionId:e.sessionId});let o={message:a};for(;;){let a=await i.client.send(o);(s.cancelRequested||s.protocolCancelled)&&await this.#o(i);let c=[],l=!1,u,d;for await(let n of a){let r=`data`in n&&`turnId`in n.data?n.data.turnId:void 0;typeof r==`string`&&(s.turnId=r),n.type===`input.requested`&&c.push(...n.data.requests),n.type===`authorization.required`&&(d=unsupported(`Connection authorization cannot be completed through eve ACP mode.`)),n.type===`turn.cancelled`&&(l=!0),(n.type===`turn.failed`||n.type===`session.failed`)&&(u=n),await this.#c(e.sessionId,i,n,t)}if(s.protocolCancelled)throw RequestError.requestCancelled({sessionId:e.sessionId});if(l||s.cancelRequested)return{stopReason:`cancelled`};if(u!==void 0)throw eveFailure(u);if(d!==void 0)throw d;if(c.length===0)return{stopReason:`end_turn`};let f;try{f=await Promise.all(c.map(r=>this.#l(e.sessionId,i,r,t,n)))}catch(t){if(s.protocolCancelled)throw RequestError.requestCancelled({sessionId:e.sessionId});if(s.cancelRequested)return{stopReason:`cancelled`};throw t}if(s.protocolCancelled)throw RequestError.requestCancelled({sessionId:e.sessionId});if(s.cancelRequested)return{stopReason:`cancelled`};o={inputResponses:f}}}catch(e){throw acpRequestError(e)}finally{n.removeEventListener(`abort`,onProtocolCancel),i.tools.clear(),s.resolveSettled(),i.active===s&&(i.active=void 0)}}async cancel(e){let t=this.#i.get(e);t===void 0||t.active===void 0||(t.active.cancelRequested=!0,await this.#o(t))}async closeSession(e){let t=this.#s(e);this.#i.delete(e),await this.#a(t)}async close(){let e=[...this.#i.values()];this.#i.clear(),await Promise.allSettled(e.map(e=>this.#a(e)))}async#a(e){let t;if(e.active!==void 0){let n=e.active;n.cancelRequested=!0;try{await this.#o(e)}catch(e){t=e}await n.settled}try{await e.client.reset()}catch(e){throw t===void 0?e:AggregateError([t,e],`Could not cancel or reset the eve session`)}if(t!==void 0)throw t}async#o(e){e.active?.outboundController.abort(),e.client.state.sessionId!==void 0&&await e.client.cancel(e.active?.turnId===void 0?void 0:{turnId:e.active.turnId})}#s(e){let t=this.#i.get(e);if(t===void 0)throw RequestError.invalidParams({sessionId:e},`Unknown or closed ACP session`);return t}async#c(e,t,n,r){switch(n.type){case`message.appended`:await notifyUpdate(r,e,{sessionUpdate:`agent_message_chunk`,content:{type:`text`,text:n.data.messageDelta},messageId:`${n.data.turnId}:message:${n.data.stepIndex}`});return;case`reasoning.appended`:await notifyUpdate(r,e,{sessionUpdate:`agent_thought_chunk`,content:{type:`text`,text:n.data.reasoningDelta},messageId:`${n.data.turnId}:thought:${n.data.stepIndex}`});return;case`actions.requested`:for(let i of n.data.actions){let n=toolCallForAction(i);t.tools.set(i.callId,n),await notifyUpdate(r,e,{sessionUpdate:`tool_call`,...n})}return;case`action.result`:{let t=n.data.result,i=n.data.status!==`completed`||t.isError?`failed`:`completed`;await notifyUpdate(r,e,{sessionUpdate:`tool_call_update`,toolCallId:t.callId,status:i,content:[{type:`content`,content:{type:`text`,text:stringifyOutput(t.output)}}],rawOutput:t.output});return}default:return}}async#l(e,t,n,a,o){let c=AbortSignal.any([o,t.active.outboundController.signal]);if(n.display===`confirmation`){let o=`${n.requestId}:approve`,s=`${n.requestId}:deny`,l=t.tools.get(n.action.callId)??toolCallForAction(n.action),u=await a.request(methods.client.session.requestPermission,{sessionId:e,toolCall:l,options:[{kind:`allow_once`,name:`Approve`,optionId:o},{kind:`reject_once`,name:`Deny`,optionId:s}]},{cancellationSignal:c});if(u.outcome.outcome===`cancelled`)return this.#u(t),{requestId:n.requestId};if(u.outcome.optionId===o)return{requestId:n.requestId,optionId:`approve`};if(u.outcome.optionId===s)return{requestId:n.requestId,optionId:`deny`};throw RequestError.invalidParams({optionId:u.outcome.optionId},`Unknown ACP permission option`)}if(!this.#r)throw unsupported(`The ACP client does not support form elicitation required by this eve question.`);let l=elicitationProperty(n),u=await a.request(methods.client.elicitation.create,{mode:`form`,sessionId:e,message:n.prompt,requestedSchema:{type:`object`,properties:{[ANSWER_FIELD]:l},required:[ANSWER_FIELD]}},{cancellationSignal:c});if(u.action!==`accept`)return this.#u(t),{requestId:n.requestId};let d=u.content?.[ANSWER_FIELD];if(typeof d!=`string`)throw RequestError.invalidParams(u.content,`ACP elicitation response must contain a string answer`);if(n.display===`select`){if(!n.options?.some(e=>e.id===d))throw RequestError.invalidParams({answer:d},`Unknown eve question option`);return{requestId:n.requestId,optionId:d}}return{requestId:n.requestId,text:d}}#u(e){let t=e.active;t.cancelRequested=!0,t.outboundController.abort()}};async function normalizedRealpath(e,n){try{return await realpath(e)}catch(t){throw RequestError.invalidParams({path:e},`Could not resolve ${n}: ${errorMessage(t)}`)}}function promptContent(e){let t=e.prompt.map(e=>{if(e.type!==`text`)throw unsupported(`ACP prompt content type ${JSON.stringify(e.type)} is not supported.`);return{type:`text`,text:e.text}});if(t.every(e=>e.text.length===0))throw RequestError.invalidParams(e.prompt,`ACP prompt must contain at least one non-empty text block`);return t}function toolCallForAction(e){let t=e.kind===`tool-call`?e.toolName:e.kind===`load-skill`?`Load skill`:e.name;return{toolCallId:e.callId,title:t,kind:`other`,status:`pending`,rawInput:e.input}}function elicitationProperty(e){if(e.display===`select`&&e.allowFreeform!==!0&&e.options?.length)return{type:`string`,title:e.prompt,oneOf:e.options.map(e=>({const:e.id,title:e.label,description:e.description}))};if(e.display===`text`&&e.allowFreeform!==!1)return{type:`string`,title:e.prompt,minLength:1};throw unsupported(`This eve question shape cannot be represented by ACP form elicitation.`)}async function notifyUpdate(e,t,n){await e.notify(methods.client.session.update,{sessionId:t,update:n})}function stringifyOutput(e){return typeof e==`string`?e:JSON.stringify(e,null,2)}function unsupported(e){return new RequestError(-32003,e)}function eveFailure(e){return new RequestError(ERROR_CODE_EVE,e.data.message,{code:e.data.code,details:e.data.details})}function acpRequestError(e){return e instanceof RequestError?e:e instanceof ClientError?new RequestError(ERROR_CODE_EVE,e.message,{httpStatus:e.status}):new RequestError(ERROR_CODE_EVE,errorMessage(e))}function errorMessage(e){return e instanceof Error?e.message:String(e)}export{EveAcpAdapter};
+import{randomUUID}from"node:crypto";import{realpath}from"node:fs/promises";import{PROTOCOL_VERSION,RequestError,methods}from"#compiled/@agentclientprotocol/sdk/index.js";import{Client,ClientError}from"#client/index.js";const ANSWER_FIELD=`answer`,ERROR_CODE_EVE=-32002;var EveAcpAdapter=class{#e;#t;#n;#r=!1;#i=new Map;constructor(e){this.#t=e.eveVersion,this.#n=e.workspaceRoot,this.#e=e.client??new Client({auth:e.auth,headers:e.headers,host:e.serverUrl,redirect:`manual`})}initialize(e){return this.#r=e.clientCapabilities?.elicitation?.form!==void 0,{protocolVersion:PROTOCOL_VERSION,agentCapabilities:{loadSession:!1,promptCapabilities:{},sessionCapabilities:{close:{}}},agentInfo:{name:`eve`,title:`eve`,version:this.#t},authMethods:[]}}async newSession(t){if(t.mcpServers.length>0)throw unsupported(`Client-provided MCP servers are not supported by eve ACP mode.`);if((t.additionalDirectories?.length??0)>0)throw unsupported(`Additional workspace directories are not supported by eve ACP mode.`);if(this.#n!==void 0){let e=await normalizedRealpath(t.cwd,`session/new.cwd`),n=await normalizedRealpath(this.#n,`the eve application root`);if(e!==n)throw RequestError.invalidParams({cwd:t.cwd,workspaceRoot:n},`ACP cwd must be the eve application root`)}let n=randomUUID();return this.#i.set(n,{tools:new Map}),{sessionId:n}}async prompt(e,t,n){let i=this.#s(e.sessionId);if(i.active!==void 0)throw new RequestError(-32001,`ACP session ${e.sessionId} already has an active prompt.`);let a=promptContent(e);i.tools.clear();let o=Promise.withResolvers(),s={cancelRequested:!1,protocolCancelled:!1,outboundController:new AbortController,settled:o.promise,resolveSettled:o.resolve};i.active=s;let onProtocolCancel=()=>{s.protocolCancelled=!0,this.#o(i).catch(()=>void 0)};n.aborted?onProtocolCancel():n.addEventListener(`abort`,onProtocolCancel,{once:!0});try{if(s.protocolCancelled)throw RequestError.requestCancelled({sessionId:e.sessionId});let o={message:a};for(;;){let a;if(i.client===void 0){if(o.message===void 0)throw Error(`ACP session has not started.`);let e=await this.#e.sessions.create({...o,message:o.message});i.client=e.session,a=e.response}else a=o.inputResponses===void 0?await i.client.send(o.message):await i.client.respond(o.inputResponses);(s.cancelRequested||s.protocolCancelled)&&await this.#o(i);let c=[],l=!1,u,d;for await(let n of a){let r=`data`in n&&`turnId`in n.data?n.data.turnId:void 0;typeof r==`string`&&(s.turnId=r),n.type===`input.requested`&&c.push(...n.data.requests),n.type===`authorization.required`&&(d=unsupported(`Connection authorization cannot be completed through eve ACP mode.`)),n.type===`turn.cancelled`&&(l=!0),(n.type===`turn.failed`||n.type===`session.failed`)&&(u=n),await this.#c(e.sessionId,i,n,t)}if(s.protocolCancelled)throw RequestError.requestCancelled({sessionId:e.sessionId});if(l||s.cancelRequested)return{stopReason:`cancelled`};if(u!==void 0)throw eveFailure(u);if(d!==void 0)throw d;if(c.length===0)return{stopReason:`end_turn`};let f;try{f=await Promise.all(c.map(r=>this.#l(e.sessionId,i,r,t,n)))}catch(t){if(s.protocolCancelled)throw RequestError.requestCancelled({sessionId:e.sessionId});if(s.cancelRequested)return{stopReason:`cancelled`};throw t}if(s.protocolCancelled)throw RequestError.requestCancelled({sessionId:e.sessionId});if(s.cancelRequested)return{stopReason:`cancelled`};o={inputResponses:f}}}catch(e){throw acpRequestError(e)}finally{n.removeEventListener(`abort`,onProtocolCancel),i.tools.clear(),s.resolveSettled(),i.active===s&&(i.active=void 0)}}async cancel(e){let t=this.#i.get(e);t===void 0||t.active===void 0||(t.active.cancelRequested=!0,await this.#o(t))}async closeSession(e){let t=this.#s(e);this.#i.delete(e),await this.#a(t)}async close(){let e=[...this.#i.values()];this.#i.clear(),await Promise.allSettled(e.map(e=>this.#a(e)))}async#a(e){let t;if(e.active!==void 0){let n=e.active;n.cancelRequested=!0;try{await this.#o(e)}catch(e){t=e}await n.settled}try{await e.client?.reset()}catch(e){throw t===void 0?e:AggregateError([t,e],`Could not cancel or reset the eve session`)}if(t!==void 0)throw t}async#o(e){e.active?.outboundController.abort(),e.client!==void 0&&await e.client.cancel(e.active?.turnId===void 0?void 0:{turnId:e.active.turnId})}#s(e){let t=this.#i.get(e);if(t===void 0)throw RequestError.invalidParams({sessionId:e},`Unknown or closed ACP session`);return t}async#c(e,t,n,r){switch(n.type){case`message.appended`:await notifyUpdate(r,e,{sessionUpdate:`agent_message_chunk`,content:{type:`text`,text:n.data.messageDelta},messageId:`${n.data.turnId}:message:${n.data.stepIndex}`});return;case`reasoning.appended`:await notifyUpdate(r,e,{sessionUpdate:`agent_thought_chunk`,content:{type:`text`,text:n.data.reasoningDelta},messageId:`${n.data.turnId}:thought:${n.data.stepIndex}`});return;case`actions.requested`:for(let i of n.data.actions){let n=toolCallForAction(i);t.tools.set(i.callId,n),await notifyUpdate(r,e,{sessionUpdate:`tool_call`,...n})}return;case`action.result`:{let t=n.data.result,i=n.data.status!==`completed`||t.isError?`failed`:`completed`;await notifyUpdate(r,e,{sessionUpdate:`tool_call_update`,toolCallId:t.callId,status:i,content:[{type:`content`,content:{type:`text`,text:stringifyOutput(t.output)}}],rawOutput:t.output});return}default:return}}async#l(e,t,n,a,o){let c=AbortSignal.any([o,t.active.outboundController.signal]);if(n.display===`confirmation`){let o=`${n.requestId}:approve`,s=`${n.requestId}:deny`,l=t.tools.get(n.action.callId)??toolCallForAction(n.action),u=await a.request(methods.client.session.requestPermission,{sessionId:e,toolCall:l,options:[{kind:`allow_once`,name:`Approve`,optionId:o},{kind:`reject_once`,name:`Deny`,optionId:s}]},{cancellationSignal:c});if(u.outcome.outcome===`cancelled`)return this.#u(t),{requestId:n.requestId};if(u.outcome.optionId===o)return{requestId:n.requestId,optionId:`approve`};if(u.outcome.optionId===s)return{requestId:n.requestId,optionId:`deny`};throw RequestError.invalidParams({optionId:u.outcome.optionId},`Unknown ACP permission option`)}if(!this.#r)throw unsupported(`The ACP client does not support form elicitation required by this eve question.`);let l=elicitationProperty(n),u=await a.request(methods.client.elicitation.create,{mode:`form`,sessionId:e,message:n.prompt,requestedSchema:{type:`object`,properties:{[ANSWER_FIELD]:l},required:[ANSWER_FIELD]}},{cancellationSignal:c});if(u.action!==`accept`)return this.#u(t),{requestId:n.requestId};let d=u.content?.[ANSWER_FIELD];if(typeof d!=`string`)throw RequestError.invalidParams(u.content,`ACP elicitation response must contain a string answer`);if(n.display===`select`){if(!n.options?.some(e=>e.id===d))throw RequestError.invalidParams({answer:d},`Unknown eve question option`);return{requestId:n.requestId,optionId:d}}return{requestId:n.requestId,text:d}}#u(e){let t=e.active;t.cancelRequested=!0,t.outboundController.abort()}};async function normalizedRealpath(e,n){try{return await realpath(e)}catch(t){throw RequestError.invalidParams({path:e},`Could not resolve ${n}: ${errorMessage(t)}`)}}function promptContent(e){let t=e.prompt.map(e=>{if(e.type!==`text`)throw unsupported(`ACP prompt content type ${JSON.stringify(e.type)} is not supported.`);return{type:`text`,text:e.text}});if(t.every(e=>e.text.length===0))throw RequestError.invalidParams(e.prompt,`ACP prompt must contain at least one non-empty text block`);return t}function toolCallForAction(e){let t=e.kind===`tool-call`?e.toolName:e.kind===`load-skill`?`Load skill`:e.name;return{toolCallId:e.callId,title:t,kind:`other`,status:`pending`,rawInput:e.input}}function elicitationProperty(e){if(e.display===`select`&&e.allowFreeform!==!0&&e.options?.length)return{type:`string`,title:e.prompt,oneOf:e.options.map(e=>({const:e.id,title:e.label,description:e.description}))};if(e.display===`text`&&e.allowFreeform!==!1)return{type:`string`,title:e.prompt,minLength:1};throw unsupported(`This eve question shape cannot be represented by ACP form elicitation.`)}async function notifyUpdate(e,t,n){await e.notify(methods.client.session.update,{sessionId:t,update:n})}function stringifyOutput(e){return typeof e==`string`?e:JSON.stringify(e,null,2)}function unsupported(e){return new RequestError(-32003,e)}function eveFailure(e){return new RequestError(ERROR_CODE_EVE,e.data.message,{code:e.data.code,details:e.data.details})}function acpRequestError(e){return e instanceof RequestError?e:e instanceof ClientError?new RequestError(ERROR_CODE_EVE,e.message,{httpStatus:e.status}):new RequestError(ERROR_CODE_EVE,errorMessage(e))}function errorMessage(e){return e instanceof Error?e.message:String(e)}export{EveAcpAdapter};

package/dist/src/channel/adapter-context.d.ts

@@ -6,6 +6,6 @@ import type { ChannelAdapter, ChannelAdapterContext } from "#channel/adapter.js"
  *
  * Populates `session` with a live {@link SessionHandle} backed by the
  * supplied accessor so handlers can read identity / auth and call
- * `setContinuationToken(...)` to re-key the parked session.
+ * `session.continuation.rekey(...)` to re-key the parked session.
  */
 export declare function buildAdapterContext<TCtx extends ChannelAdapterContext<any> = ChannelAdapterContext>(adapter: ChannelAdapter<TCtx>, accessor: ContextAccessor): TCtx;

package/dist/src/channel/adapter.d.ts

@@ -14,7 +14,7 @@ import type { FetchFileResult, FetchFileFunction } from "#shared/channel-definit
  * {@link ContextAccessor} that tools and providers use).
  *
  * `session` is a live handle to the current session — id, auth,
- * continuation token, plus an imperative {@link SessionHandle.setContinuationToken}
+ * optional channel continuation address, including an imperative `rekey()`
  * for channels that need to re-key the session mid-turn (e.g. Slack's
  * auto-anchor on first post).
  */
@@ -148,9 +148,7 @@ export declare function defaultDeliverResult(payload: DeliverPayload): StepInput
 export declare function getAdapterKind(adapter: ChannelAdapter): string;
 /**
  * Calls an adapter's event handler for a given event. Adapters perform side
- * effects rather than transforming events; after the handler runs, the
- * runtime refreshes `session.waiting` with the live continuation token so a
- * handler that re-keyed the session publishes the new resume handle.
+ * effects rather than transforming events.
  *
  * Throwing handlers are logged and swallowed so a downstream delivery
  * failure does not corrupt the event stream write path.

package/dist/src/channel/adapter.js

@@ -1 +1 @@
-import{createLogger}from"#internal/logging.js";import{toChannelLocalContinuationToken}from"#shared/continuation-token.js";const log=createLogger(`channel.adapter`);function defaultDeliverResult(e){if(e.message!==void 0)return{inputResponses:e.inputResponses,message:e.message,context:e.context,outputSchema:e.outputSchema};if(e.inputResponses!==void 0&&e.inputResponses.length>0)return{inputResponses:e.inputResponses,context:e.context,outputSchema:e.outputSchema};if(e.context!==void 0&&e.context.length>0)return{context:e.context,outputSchema:e.outputSchema};if(e.outputSchema!==void 0)return{outputSchema:e.outputSchema}}function getAdapterKind(e){return e.kind}async function callAdapterEventHandler(e,n,r){let i=e[n.type];if(i!==void 0)try{await i(`data`in n?n.data:void 0,r)}catch(t){log.error(`adapter event handler threw — event swallowed`,{adapterKind:getAdapterKind(e),eventType:n.type,error:t})}return n.type===`session.waiting`?{...n,data:{...n.data,continuationToken:toChannelLocalContinuationToken(r.session.continuationToken)}}:n}export{callAdapterEventHandler,defaultDeliverResult,getAdapterKind};
+import{createLogger}from"#internal/logging.js";const log=createLogger(`channel.adapter`);function defaultDeliverResult(e){if(e.message!==void 0)return{inputResponses:e.inputResponses,message:e.message,context:e.context,outputSchema:e.outputSchema};if(e.inputResponses!==void 0&&e.inputResponses.length>0)return{inputResponses:e.inputResponses,context:e.context,outputSchema:e.outputSchema};if(e.context!==void 0&&e.context.length>0)return{context:e.context,outputSchema:e.outputSchema};if(e.outputSchema!==void 0)return{outputSchema:e.outputSchema}}function getAdapterKind(e){return e.kind}async function callAdapterEventHandler(e,n,r){let i=withWaitingContinuationToken(n,r),a=e[n.type];if(a!==void 0)try{await a(`data`in i?i.data:void 0,r)}catch(r){log.error(`adapter event handler threw — event swallowed`,{adapterKind:getAdapterKind(e),eventType:n.type,error:r})}return withWaitingContinuationToken(i,r)}function withWaitingContinuationToken(e,t){return e.type===`session.waiting`?{...e,data:{...e.data,continuationToken:t.session.continuation?.token??t.session.id}}:e}export{callAdapterEventHandler,defaultDeliverResult,getAdapterKind};

package/dist/src/channel/channel-address.d.ts

@@ -0,0 +1,58 @@
+import type { UserContent } from "ai";
+import type { ChannelAdapter } from "#channel/adapter.js";
+import type { SendPayload } from "#channel/routes.js";
+import { type Session } from "#channel/session.js";
+import type { CancelTurnResult, ClearSessionResult, CompactSessionResult, ResetSessionResult, Runtime, SessionAuthContext, SessionCallback } from "#channel/types.js";
+import type { RunMode } from "#shared/run-mode.js";
+interface BaseChannelAddressDeliveryOptions {
+    readonly auth: SessionAuthContext | null;
+    readonly callback?: SessionCallback;
+    readonly initiatorAuth?: SessionAuthContext | null;
+    readonly mode?: RunMode;
+    readonly title?: string;
+}
+/** Delivery options for a channel address whose continuation token is already bound. */
+export type ChannelAddressDeliveryOptions<TState = undefined> = [TState] extends [undefined] ? BaseChannelAddressDeliveryOptions : BaseChannelAddressDeliveryOptions & {
+    readonly state?: TState;
+};
+/**
+ * Dynamic handle for whichever durable session currently owns one channel-local address.
+ * Only {@link send} may create a session when the address is unowned.
+ */
+export interface ChannelAddress<TState = undefined> {
+    readonly continuationToken: string;
+    deliver(input: SendPayload, options: ChannelAddressDeliveryOptions<TState>): Promise<Session>;
+    send(message: string | UserContent, options: ChannelAddressDeliveryOptions<TState>): Promise<Session>;
+    respond(inputResponses: SendPayload["inputResponses"], options: ChannelAddressDeliveryOptions<TState>): Promise<Session>;
+    cancel(options?: {
+        readonly turnId?: string;
+    }): Promise<CancelTurnResult>;
+    compact(): Promise<CompactSessionResult>;
+    clear(): Promise<ClearSessionResult>;
+    reset(options?: {
+        readonly reason?: string;
+    }): Promise<ResetSessionResult>;
+    resolveSession(): Promise<Session | undefined>;
+}
+/** Factory for binding a route-local continuation token to a {@link ChannelAddress}. */
+export type ChannelAddressFn<TState = undefined> = (continuationToken: string) => ChannelAddress<TState>;
+/** Creates one channel address backed by the runtime's continuation dispatch primitive. */
+export declare function createChannelAddress<TState = undefined>(input: {
+    readonly adapter: ChannelAdapter<any>;
+    readonly channelName: string;
+    readonly continuationToken: string;
+    readonly metadata?: {
+        readonly requestId?: string;
+    };
+    readonly runtime: Runtime;
+}): ChannelAddress<TState>;
+/** Builds a request-scoped factory for channel addresses on one authored channel. */
+export declare function createChannelAddressFn<TState = undefined>(input: {
+    readonly adapter: ChannelAdapter<any>;
+    readonly channelName: string;
+    readonly metadata?: {
+        readonly requestId?: string;
+    };
+    readonly runtime: Runtime;
+}): ChannelAddressFn<TState>;
+export {};

package/dist/src/channel/channel-address.js

@@ -0,0 +1 @@
+import{createSession,sessionCallbackToTurnCaller}from"#channel/session.js";import{normalizeSendInput,serializeUrlFilePartsInMessage}from"#channel/send-input.js";import{isRuntimeSessionOwnershipConflictError}from"#execution/runtime-errors.js";import{isReservedSessionCommandToken}from"#execution/session-command-token.js";function createChannelAddress(r){let i=r.metadata??{},a=`${r.channelName}:${r.continuationToken}`;if(isReservedSessionCommandToken(a))throw Error(`Channel address "${a}" uses eve's reserved session namespace.`);return{continuationToken:r.continuationToken,async deliver(n,o){let s=normalizeSendInput(n),c=sessionCallbackToTurnCaller(o.callback),l={auth:o.auth,kind:`send`,payload:{...s,message:serializeUrlFilePartsInMessage(s.message)},requestId:i.requestId},u=c===void 0?l:{...l,caller:c},dispatch=async()=>{let t=await r.runtime.dispatchContinuation({command:u,continuationToken:a});return t.status===`accepted`?createSession(t.sessionId,r.runtime,i):void 0},d=await dispatch();if(d!==void 0)return d;if(s.inputResponses&&s.inputResponses.length>0)throw Error(`Cannot deliver inputResponses — the target session was not found via continuation token.`);let f=o.state,p={adapter:f===void 0?r.adapter:{...r.adapter,state:{...r.adapter.state,...f}},auth:o.auth,capabilities:o.mode===`task`?void 0:{requestInput:!0},callback:o.callback,channelName:r.channelName,continuationToken:a,initiatorAuth:o.initiatorAuth,input:{context:s.context,message:serializeUrlFilePartsInMessage(s.message)??``,outputSchema:s.outputSchema},mode:o.mode??`conversation`,requestId:i.requestId,title:o.title};try{return createSession((await r.runtime.createSession(p)).sessionId,r.runtime,i)}catch(e){if(!isRuntimeSessionOwnershipConflictError(e))throw e;let t=await dispatch();if(t!==void 0)return t;throw e}},async send(e,t){return await this.deliver({message:e},t)},async respond(e,t){if(e===void 0||e.length===0)throw Error(`respond() requires at least one input response.`);return await this.deliver({inputResponses:e},t)},async cancel(e){return await r.runtime.dispatchContinuation({command:{kind:`cancel`,turnId:e?.turnId},continuationToken:a})},async compact(){return await r.runtime.dispatchContinuation({command:{kind:`compact`},continuationToken:a})},async clear(){return await r.runtime.dispatchContinuation({command:{kind:`clear`},continuationToken:a})},async reset(e){return await r.runtime.dispatchContinuation({command:{kind:`reset`,reason:e?.reason},continuationToken:a})},async resolveSession(){let t=await r.runtime.resolveContinuation(a);return t===void 0?void 0:createSession(t.sessionId,r.runtime,i)}}}function createChannelAddressFn(e){return t=>createChannelAddress({...e,continuationToken:t})}export{createChannelAddress,createChannelAddressFn};

package/dist/src/channel/channel-operations.d.ts

@@ -0,0 +1,72 @@
+import type { UserContent } from "ai";
+import type { ChannelAdapter } from "#channel/adapter.js";
+import { type ChannelAddressDeliveryOptions } from "#channel/channel-address.js";
+import type { SendPayload } from "#channel/routes.js";
+import type { Session } from "#channel/session.js";
+import type { CancelTurnResult, ClearSessionResult, CompactSessionResult, ResetSessionResult, Runtime, SessionAuthContext, SessionCallback } from "#channel/types.js";
+import type { InputResponse } from "#runtime/input/types.js";
+import type { JsonObject } from "#shared/json.js";
+import type { RunMode } from "#shared/run-mode.js";
+interface BaseChannelSendOptions {
+    readonly auth: SessionAuthContext | null;
+    readonly callback?: SessionCallback;
+    readonly context?: readonly string[];
+    readonly initiatorAuth?: SessionAuthContext | null;
+    readonly mode?: RunMode;
+    readonly outputSchema?: JsonObject;
+    readonly title?: string;
+}
+/** Options for sending a message from a channel-local continuation address. */
+export type ChannelSendOptions<TState = undefined> = [TState] extends [undefined] ? BaseChannelSendOptions : BaseChannelSendOptions & {
+    readonly state: TState;
+};
+interface BaseChannelRespondOptions {
+    readonly auth: SessionAuthContext | null;
+    readonly context?: readonly string[];
+    readonly outputSchema?: JsonObject;
+}
+/** Options for answering pending input requests at an existing continuation address. */
+export type ChannelRespondOptions = BaseChannelRespondOptions;
+/** Dynamic handle for whichever session currently owns one channel-local address. */
+export interface ChannelSource<TState = undefined> {
+    /** Starts or resumes a turn with a user message. May create a session. */
+    send(message: string | UserContent, options: ChannelSendOptions<TState>): Promise<Session>;
+    /** Answers pending input requests. Never creates a session. */
+    respond(inputResponses: readonly InputResponse[], options: ChannelRespondOptions): Promise<Session>;
+    /** Cooperatively cancels the active turn without creating a session. */
+    cancel(options?: {
+        readonly turnId?: string;
+    }): Promise<CancelTurnResult>;
+    /** Queues context compaction without creating a session. */
+    compact(): Promise<CompactSessionResult>;
+    /** Clears model-message history without creating a session. */
+    clear(): Promise<ClearSessionResult>;
+    /** Retires the current owner without creating a replacement. */
+    reset(options?: {
+        readonly reason?: string;
+    }): Promise<ResetSessionResult>;
+}
+/** Binds a raw channel-local continuation address to its current-owner operations. */
+export type ChannelFrom<TState = undefined> = (address: string) => ChannelSource<TState>;
+/** Snapshots the session currently owning a channel-local continuation address. */
+export type ChannelResolveSession = (address: string) => Promise<Session | undefined>;
+/** Continuation operations passed to an authored channel's proactive `receive` hook. */
+export interface ChannelReceiveContext<TState = undefined> {
+    readonly from: ChannelFrom<TState>;
+    readonly resolveSession: ChannelResolveSession;
+}
+export declare const INTERNAL_CHANNEL_DELIVER: unique symbol;
+/** @internal Permissive transport delivery retained below public authoring surfaces. */
+export interface InternalChannelSource<TState = undefined> extends ChannelSource<TState> {
+    [INTERNAL_CHANNEL_DELIVER](payload: SendPayload, options: ChannelAddressDeliveryOptions<TState>): Promise<Session>;
+}
+/** Creates request-scoped channel operations backed by continuation dispatch. */
+export declare function createChannelOperations<TState = undefined>(input: {
+    readonly adapter: ChannelAdapter<any>;
+    readonly channelName: string;
+    readonly metadata?: {
+        readonly requestId?: string;
+    };
+    readonly runtime: Runtime;
+}): ChannelReceiveContext<TState>;
+export {};

package/dist/src/channel/channel-operations.js

@@ -0,0 +1 @@
+import{createChannelAddressFn}from"#channel/channel-address.js";const INTERNAL_CHANNEL_DELIVER=Symbol(`eve.internal.channel-deliver`);function createChannelOperations(n){let r=createChannelAddressFn(n);return{from(e){let n=r(e);return{async send(e,t){return await n.deliver({context:t.context,message:e,outputSchema:t.outputSchema},t)},async respond(e,t){if(e.length===0)throw Error(`respond() requires at least one input response.`);return await n.deliver({context:t.context,inputResponses:e,outputSchema:t.outputSchema},t)},async cancel(e){return await n.cancel(e)},async compact(){return await n.compact()},async clear(){return await n.clear()},async reset(e){return await n.reset(e)},async[INTERNAL_CHANNEL_DELIVER](e,t){return await n.deliver(e,t)}}},async resolveSession(e){return await r(e).resolveSession()}}}export{INTERNAL_CHANNEL_DELIVER,createChannelOperations};

package/dist/src/channel/compiled-channel.d.ts

@@ -1,22 +1,26 @@
 import type { ChannelAdapter } from "#channel/adapter.js";
+import type { UserContent } from "ai";
+import type { ChannelReceiveContext } from "#channel/channel-operations.js";
 import type { NormalizedChannelCorsOptions } from "#channel/cors.js";
-import type { RouteDefinition, SendFn } from "#channel/routes.js";
+import type { TypedReceiveTarget } from "#channel/receive-target.js";
+import type { RouteDefinition } from "#channel/routes.js";
 import type { Session } from "#channel/session.js";
 import type { SessionAuthContext } from "#channel/types.js";
 export declare const CHANNEL_SENTINEL: "eve:channel";
-export interface CompiledChannel<TState = undefined, TReceiveTarget = Record<string, unknown>, TMetadata extends Record<string, unknown> = Record<string, unknown>> {
+/** Structural identity shared by public authored channels and compiled channels. */
+export interface ChannelReference<TReceiveTarget = Record<string, unknown>> extends TypedReceiveTarget<TReceiveTarget> {
     readonly __kind: typeof CHANNEL_SENTINEL;
+}
+export interface CompiledChannel<TState = undefined, TReceiveTarget = Record<string, unknown>, TMetadata extends Record<string, unknown> = Record<string, unknown>> extends ChannelReference<TReceiveTarget> {
     readonly routes: readonly RouteDefinition<TState>[];
     readonly adapter: ChannelAdapter<any>;
     readonly cors?: NormalizedChannelCorsOptions;
     readonly __metadata?: TMetadata;
     readonly receive?: (input: {
-        readonly message: string;
+        readonly message: string | UserContent;
         readonly target: Readonly<TReceiveTarget>;
         readonly auth: SessionAuthContext | null;
-    }, args: {
-        send: SendFn<TState>;
-    }) => Promise<Session>;
+    }, ctx: ChannelReceiveContext<TState>) => Promise<Session>;
 }
 export declare function isCompiledChannel(value: unknown): value is CompiledChannel;
 export declare function getChannelInstrumentationKind(value: unknown): string | undefined;

package/dist/src/channel/cross-channel-receive.d.ts

@@ -1,28 +1,22 @@
 import type { UserContent } from "ai";
 import type { ChannelAdapter } from "#channel/adapter.js";
-import { type CompiledChannel } from "#channel/compiled-channel.js";
+import { type ChannelReference, type CompiledChannel } from "#channel/compiled-channel.js";
 import type { InferReceiveTarget } from "#channel/receive-target.js";
 import type { Session } from "#channel/session.js";
 import type { Runtime, SessionAuthContext } from "#channel/types.js";
 import type { ResolvedChannelDefinition } from "#runtime/types.js";
 /**
- * Options accepted by {@link CrossChannelReceiveFn}. Mirrors the input
- * argument of a channel's authored `receive(input, { send })` hook —
- * the runtime constructs `send` internally so route-handler callers
- * only supply the platform target, payload, and auth.
+ * Options for sending a message to a channel selected with `ctx.to(...)`.
  */
-export interface CrossChannelReceiveOptions<TTarget = Record<string, unknown>> {
-    readonly message: string | UserContent;
-    readonly target: TTarget;
+export interface CrossChannelSendOptions {
     readonly auth: SessionAuthContext | null;
 }
-/**
- * Starts a session on a different channel from inside a route handler.
- * The target channel's authored `receive` hook owns continuation-token
- * format and initial state; `auth` is forwarded verbatim and becomes
- * `session.initiatorAuth`.
- */
-export type CrossChannelReceiveFn = <TChannel>(channel: TChannel, options: CrossChannelReceiveOptions<InferReceiveTarget<TChannel>>) => Promise<Session>;
+/** Message delivery bound to one channel-specific proactive target. */
+export interface CrossChannelTargetHandle {
+    send(message: string | UserContent, options: CrossChannelSendOptions): Promise<Session>;
+}
+/** Selects another authored channel and one of its proactive targets. */
+export type CrossChannelToFn = <TChannel extends ChannelReference>(channel: TChannel, target: InferReceiveTarget<TChannel>) => CrossChannelTargetHandle;
 /**
  * Channel record consumed by the receiver — keeps the public-facing
  * `definition` reference so callers can identify a target by value
@@ -43,17 +37,14 @@ export interface CrossChannelTarget {
  */
 export declare function toCrossChannelTargets(channels: readonly ResolvedChannelDefinition[]): readonly CrossChannelTarget[];
 /**
- * Builds the `args.receive` closure used by every route handler. The
- * closure resolves the target channel by reference identity against
- * the request-scoped channel bundle, then delegates to the target's
- * authored `receive` hook with a per-target `send` factory.
+ * Builds the `ctx.to(channel, target)` closure used by route and schedule handlers.
  */
-export declare function createCrossChannelReceiveFn(runtime: Runtime, channels: readonly CrossChannelTarget[]): CrossChannelReceiveFn;
+export declare function createCrossChannelToFn(runtime: Runtime, channels: readonly CrossChannelTarget[]): CrossChannelToFn;
 interface InvokeChannelReceiveInput {
     readonly runtime: Runtime;
     readonly target: Pick<CrossChannelTarget, "name" | "receive" | "adapter">;
     readonly input: {
-        readonly message: string;
+        readonly message: string | UserContent;
         readonly target: Readonly<Record<string, unknown>>;
         readonly auth: SessionAuthContext | null;
     };
@@ -61,10 +52,7 @@ interface InvokeChannelReceiveInput {
     readonly describeMissingAdapter: () => string;
 }
 /**
- * Shared `receive(input, { send })` invocation used by both the route-
- * handler cross-channel surface and the schedule dispatcher. Owns the
- * receive/adapter precondition checks and the per-target `send`
- * factory so both call sites stay byte-identical.
+ * Shared authored `receive(input, ctx)` invocation used by route and schedule delivery.
  */
 export declare function invokeChannelReceive(args: InvokeChannelReceiveInput): Promise<Session>;
 export {};

package/dist/src/channel/cross-channel-receive.js

@@ -1,2 +1,2 @@
-import{isCompiledChannel}from"#channel/compiled-channel.js";import{createSendFn}from"#channel/send.js";function toCrossChannelTargets(e){return e.flatMap(e=>e.definition===void 0?[]:[{name:e.name,definition:e.definition,receive:e.receive,adapter:e.adapter}])}function createCrossChannelReceiveFn(e,t){return async(n,r)=>{let i=resolveTargetByReference(n,t);return await invokeChannelReceive({runtime:e,target:i,input:{message:r.message,target:r.target,auth:r.auth},describeMissingReceive:()=>`args.receive(): channel "${i.name}" does not implement receive(). Declare a receive hook on the channel to accept cross-channel sessions.`,describeMissingAdapter:()=>`args.receive(): channel "${i.name}" has no adapter — cannot build send().`})}}async function invokeChannelReceive(e){if(!e.target.receive)throw Error(e.describeMissingReceive());if(!e.target.adapter)throw Error(e.describeMissingAdapter());let n=createSendFn(e.runtime,e.target.adapter,e.target.name);return await e.target.receive(e.input,{send:n})}function resolveTargetByReference(e,t){for(let n of t)if(n.definition===e)return n;let n=resolveTargetByRouteFingerprint(e,t);if(n!==null)return n;throw Error(`args.receive(): the channel passed as the first argument is not registered in this agent's channels/. Import the channel module's default export from agent/channels/<name>.ts and pass that value.`)}function resolveTargetByRouteFingerprint(t,n){if(!isCompiledChannel(t))return null;let r=createRouteFingerprint(t);if(r===null)return null;let i=new Map;for(let e of n)createRouteFingerprint(e.definition)===r&&i.set(e.name,e);if(i.size===1)return[...i.values()][0];if(i.size>1)throw Error(`args.receive(): the channel passed as the first argument matches multiple registered channels by route shape. Import a channel with a unique route set from agent/channels/<name>.ts before passing it to args.receive().`);return null}function createRouteFingerprint(e){return e.routes.length===0?null:e.routes.map(e=>`${e.method.toUpperCase()} ${e.path}`).sort().join(`
-`)}export{createCrossChannelReceiveFn,invokeChannelReceive,toCrossChannelTargets};
+import{createChannelOperations}from"#channel/channel-operations.js";import{isCompiledChannel}from"#channel/compiled-channel.js";function toCrossChannelTargets(e){return e.flatMap(e=>e.definition===void 0?[]:[{name:e.name,definition:e.definition,receive:e.receive,adapter:e.adapter}])}function createCrossChannelToFn(e,t){return(n,r)=>{let i=resolveTargetByReference(n,t);return{async send(t,n){return await invokeChannelReceive({runtime:e,target:i,input:{message:t,target:r,auth:n.auth},describeMissingReceive:()=>`ctx.to(): channel "${i.name}" does not implement receive(). Declare a receive hook on the channel to accept cross-channel sessions.`,describeMissingAdapter:()=>`ctx.to(): channel "${i.name}" has no adapter — cannot build ctx.from().`})}}}}async function invokeChannelReceive(t){if(!t.target.receive)throw Error(t.describeMissingReceive());if(!t.target.adapter)throw Error(t.describeMissingAdapter());let n=createChannelOperations({adapter:t.target.adapter,channelName:t.target.name,runtime:t.runtime});return await t.target.receive(t.input,n)}function resolveTargetByReference(e,t){for(let n of t)if(n.definition===e)return n;let n=resolveTargetByRouteFingerprint(e,t);if(n!==null)return n;throw Error(`ctx.to(): the channel passed as the first argument is not registered in this agent's channels/. Import the channel module's default export from agent/channels/<name>.ts and pass that value.`)}function resolveTargetByRouteFingerprint(e,n){if(!isCompiledChannel(e))return null;let r=createRouteFingerprint(e);if(r===null)return null;let i=new Map;for(let e of n)createRouteFingerprint(e.definition)===r&&i.set(e.name,e);if(i.size===1)return[...i.values()][0];if(i.size>1)throw Error(`ctx.to(): the channel passed as the first argument matches multiple registered channels by route shape. Import a channel with a unique route set from agent/channels/<name>.ts before passing it to ctx.to().`);return null}function createRouteFingerprint(e){return e.routes.length===0?null:e.routes.map(e=>`${e.method.toUpperCase()} ${e.path}`).sort().join(`
+`)}export{createCrossChannelToFn,invokeChannelReceive,toCrossChannelTargets};

package/dist/src/channel/receive-target.d.ts

@@ -2,8 +2,7 @@ declare const receiveTargetMarker: unique symbol;
 /**
  * Structural marker that channel factories (e.g. `slackChannel`,
  * `twilioChannel`) add to declare the target type their `receive()` accepts.
- * `receive(channel, { target })` helpers and the route-handler
- * `args.receive(channel, ...)` read this marker to infer typed targets
+ * `ctx.to(channel, target)` helpers read this marker to infer typed targets
  * from a plain channel import.
  */
 export interface TypedReceiveTarget<TTarget = Record<string, unknown>> {