eve 0.29.3 → 0.29.5

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # eve
 
+## 0.29.5
+
+### Patch Changes
+
+- c0dc572: Rename the TUI `/new` command to `/reset` so session reset uses the same name across the client, HTTP, channel, and TUI APIs.
+- 3dce30a: Add manual session compaction through custom-channel helpers, the eve HTTP client, and the `eve dev` TUI's `/compact` command. Compaction preserves the session, queues behind an active turn, and does not send synthetic model input.
+- 910805e: Make a single `Esc` cancel the running turn in the eve dev TUI when no message is queued. Queued messages still use `Esc` to steer the oldest message into the next turn.
+- 9c51755: Connection search and discovered connection tools now use the same `defineDynamic` and `defineTool` pipeline as authored tools. Dynamic tool maps now reject entries that omit `defineTool` instead of accepting unsupported raw objects.
+- 84aa671: Clarify the dev TUI’s `/add` flow with consistent integration categories and category-specific browsing labels. MCP connections are now named explicitly, and the flow more clearly explains channels, extensions, and observability integrations.
+- 0c28eb7: Allow declared subagents to export `defineDynamic` from `agent.ts`. Session and turn resolvers can now return an agent configuration to expose it or nil to omit it from direct and Workflow delegation.
+- f3bb60d: Add manual session-context clearing through custom-channel helpers, the eve HTTP client, and the `eve dev` TUI's `/clear` command. Clearing removes model-message history while preserving the session, agent configuration, durable state, limits, and sandbox.
+- ac7d3c6: Add `/cancel` to the eve dev TUI. The command cooperatively cancels a running turn from either the live streaming input or the idle prompt while preserving the session and settled context.
+
+## 0.29.4
+
+### Patch Changes
+
+- e90a8c2: Launch local or deployed eve applications as stable ACP v1 agents with `eve acp [url]`, including streamed messages, tool activity, human input, cancellation, concurrent sessions, and verified Vercel authentication.
+- cec672d: Add guided Discord setup through `eve add channel/discord`, including Vercel Connect provisioning, trigger attachment, interactions endpoint configuration, slash-command registration, and channel scaffolding.
+- ed328e7: Render registry item titles with their exact registry-provided casing by loading manifests for each page of catalog results.
+- c875a67: Update the generated `AGENTS.md` to direct coding agents to the eve registry for discovering and installing integrations.
+- 5153b13: Add JSON output to `eve registry list` and `eve registry search` for scripts that inspect registry catalogs.
+- 155d46a: Connection registry items now configure their Vercel Connect connector during `eve add`, and registry setup commands close their IPC channel after reporting an outcome so `/add` returns instead of remaining stuck.
+- 6f3daca: Add `ClientSession.snapshot()` for reading a finite, cursor-consistent session event prefix that can hydrate server-rendered applications.
+- 67bfc76: Resolve sandbox skill roots and seed-file paths through the same `$HOME` resolver the file tools use, so the skills location is spelled once instead of twice.
+- a5acde8: Ensure exiting the dev TUI shuts down its owned server and any surviving workflow processes before the CLI exits. Persisted workflow messages now reach the ready worker during restart instead of being rejected while the file watcher starts.
+- 731464f: Give the local trace spool's on-disk layout a single owner: the shared trace reader now exposes the listing and segment-read primitives that `eve traces` and the `/traces` viewer both use, and payload formatting is shared between the detail panel and the conversation view.
+- f7ba3b3: Derive the `/traces` conversation viewer's line geometry from one prefix-sum helper so scroll, click, and wheel math cannot disagree, and reset the view through a single factory when the viewed trace changes.
+- 3f4bb9c: The `/traces` viewer now follows your terminal's colors instead of forcing a hardcoded black/grey truecolor palette. It probes the terminal's default background (OSC 11) and derives its card surfaces from your own theme — subtly elevated bands on dark and light backgrounds alike, with red bands for failures, and card titles that invert to black on light backgrounds so they stay legible. Terminals that don't answer the probe get a clean gutter-rail rendering drawn entirely with the shared TUI theme.
+- f5d0533: Derive the dev TUI's slash-command suggestion window from the command registry instead of a hand-maintained constant, and collapse the duplicated cursor step in the terminal line-wrap loop.
+
 ## 0.29.3
 
 ### Patch Changes

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

@@ -0,0 +1,43 @@
+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 { HandleMessageStreamEvent } from "#protocol/message.js";
+interface AdapterClientSession {
+    readonly state: SessionState;
+    send(input: SendTurnInput): Promise<AsyncIterable<HandleMessageStreamEvent>>;
+    cancel(options?: {
+        turnId?: string;
+    }): Promise<unknown>;
+    reset(): Promise<unknown>;
+}
+interface AdapterClient {
+    session(): AdapterClientSession;
+}
+/** Configuration for translating one ACP client connection to an eve server. */
+export interface EveAcpAdapterOptions {
+    readonly eveVersion: string;
+    readonly auth?: ClientOptions["auth"];
+    readonly headers?: ClientOptions["headers"];
+    readonly serverUrl: string;
+    /** Local workspace root to enforce; omit when connecting to a remote deployment. */
+    readonly workspaceRoot?: string;
+    /** @internal Test seam for the public eve client boundary. */
+    readonly client?: AdapterClient;
+}
+/**
+ * Translates stable ACP v1 sessions onto the public eve HTTP client.
+ *
+ * The adapter owns only process-local ACP identities. Conversation durability,
+ * event cursors, cancellation, and reset behavior remain owned by
+ * {@link ClientSession}.
+ */
+export declare class EveAcpAdapter {
+    #private;
+    constructor(options: EveAcpAdapterOptions);
+    initialize(params: InitializeRequest): InitializeResponse;
+    newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
+    prompt(params: PromptRequest, client: AgentContext, signal: AbortSignal): Promise<PromptResponse>;
+    cancel(sessionId: string): Promise<void>;
+    closeSession(sessionId: string): Promise<void>;
+    close(): Promise<void>;
+}
+export {};

package/dist/src/acp/adapter.js

@@ -0,0 +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};

package/dist/src/acp/line-limit.d.ts

@@ -0,0 +1,3 @@
+export declare const ACP_MAX_LINE_BYTES: number;
+/** Rejects an ACP stdio line before the SDK's line buffer can grow without bound. */
+export declare function limitAcpLineBytes(maximumBytes?: number): TransformStream<Uint8Array, Uint8Array>;

package/dist/src/acp/line-limit.js

@@ -0,0 +1 @@
+const ACP_MAX_LINE_BYTES=10*1024*1024;function limitAcpLineBytes(t=ACP_MAX_LINE_BYTES){let n=0;return new TransformStream({transform(e,r){for(let i of e){if(i===10){n=0;continue}if(n+=1,n>t){r.error(Error(`ACP message exceeds the ${t}-byte line limit.`));return}}r.enqueue(e)}})}export{ACP_MAX_LINE_BYTES,limitAcpLineBytes};

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

@@ -0,0 +1,24 @@
+import { Readable, Writable } from "node:stream";
+import { type EveAcpAdapterOptions } from "#acp/adapter.js";
+import type { ClientOptions } from "#client/types.js";
+/** Configuration for one ACP stdio connection backed by an eve server. */
+export interface RunAcpServerOptions {
+    readonly auth?: ClientOptions["auth"];
+    readonly eveVersion: string;
+    readonly headers?: ClientOptions["headers"];
+    readonly serverUrl: string;
+    readonly signal?: AbortSignal;
+    /** Local workspace root to enforce; omit when connecting to a remote deployment. */
+    readonly workspaceRoot?: string;
+    /** @internal Test seam for the public eve client boundary. */
+    readonly client?: EveAcpAdapterOptions["client"];
+}
+/** Node streams for one ACP stdio connection. */
+export interface AcpServerStreams {
+    readonly input: Readable;
+    readonly output: Writable;
+}
+/** Serves one stable ACP v1 connection over process stdio until the client disconnects. */
+export declare function runAcpServer(options: RunAcpServerOptions): Promise<void>;
+/** Serves one stable ACP v1 connection over the supplied Node streams. */
+export declare function runAcpServerOnStreams(options: RunAcpServerOptions, streams: AcpServerStreams): Promise<void>;

package/dist/src/acp/server.js

@@ -0,0 +1 @@
+import{agent,methods,ndJsonStream}from"#compiled/@agentclientprotocol/sdk/index.js";import{Readable,Writable}from"node:stream";import{EveAcpAdapter}from"#acp/adapter.js";import{limitAcpLineBytes}from"#acp/line-limit.js";async function runAcpServer(e){await runAcpServerOnStreams(e,{input:process.stdin,output:process.stdout})}async function runAcpServerOnStreams(r,i){let a=new EveAcpAdapter(r),o=agent({name:`eve`}).onRequest(methods.agent.initialize,({params:e})=>a.initialize(e)).onRequest(methods.agent.session.new,({params:e})=>a.newSession(e)).onRequest(methods.agent.session.prompt,({params:e,client:t,signal:n})=>a.prompt(e,t,n)).onRequest(methods.agent.session.close,({params:e})=>a.closeSession(e.sessionId)).onNotification(methods.agent.session.cancel,({params:e})=>a.cancel(e.sessionId)),s=Writable.toWeb(i.output),c=Readable.toWeb(i.input).pipeThrough(limitAcpLineBytes()),l=o.connect(ndJsonStream(s,c)),close=()=>l.close();r.signal?.aborted?close():r.signal?.addEventListener(`abort`,close,{once:!0});try{await l.closed}finally{r.signal?.removeEventListener(`abort`,close),await a.close()}}export{runAcpServer,runAcpServerOnStreams};

package/dist/src/channel/clear-session.d.ts

@@ -0,0 +1,4 @@
+import type { ClearFn } from "#channel/routes.js";
+import type { Runtime } from "#channel/types.js";
+/** Builds a channel-scoped context-clear helper. */
+export declare function createClearFn(runtime: Runtime, channelName: string): ClearFn;

package/dist/src/channel/clear-session.js

@@ -0,0 +1 @@
+function createClearFn(e,t){return async n=>await e.clearSession({continuationToken:`${t}:${n.continuationToken}`})}export{createClearFn};

package/dist/src/channel/compact-session.d.ts

@@ -0,0 +1,4 @@
+import type { CompactFn } from "#channel/routes.js";
+import type { Runtime } from "#channel/types.js";
+/** Builds a channel-scoped manual compaction helper. */
+export declare function createCompactFn(runtime: Runtime, channelName: string): CompactFn;

package/dist/src/channel/compact-session.js

@@ -0,0 +1 @@
+function createCompactFn(e,t){return async n=>await e.compactSession({continuationToken:`${t}:${n.continuationToken}`})}export{createCompactFn};

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

@@ -1,6 +1,6 @@
 import type { UserContent } from "ai";
 import type { CrossChannelReceiveFn } from "#channel/cross-channel-receive.js";
-import type { CancelTurnResult, SessionAuthContext, SessionCallback } from "#channel/types.js";
+import type { CancelTurnResult, ClearSessionResult, CompactSessionResult, SessionAuthContext, SessionCallback } from "#channel/types.js";
 import type { InputResponse } from "#runtime/input/types.js";
 import type { Session } from "#channel/session.js";
 import type { RunMode } from "#shared/run-mode.js";
@@ -10,11 +10,13 @@ type WebSocketHeaders = Headers | readonly (readonly [string, string])[] | Recor
 /**
  * Second argument passed to every route handler. `send` starts or continues a
  * session on this channel; `cancel` stops the active turn on a session
- * addressed by continuation token; `reset` retires a session so its
- * token can start a fresh session; `getSession` looks one up by id; `receive`
- * hands inbound work to a different channel; `params` contains the matched
- * path parameters; `waitUntil` keeps background work alive past the response;
- * `requestIp` is the client IP, or `null` when the host cannot provide it.
+ * addressed by continuation token; `clear` removes its model-message history;
+ * `compact` summarizes its context without sending model input; `reset` retires
+ * a session so its token can start a fresh session; `getSession` looks one up by
+ * id; `receive` hands inbound work to a different channel; `params` contains
+ * the matched path parameters; `waitUntil` keeps background work alive past
+ * the response; `requestIp` is the client IP, or `null` when the host cannot
+ * provide it.
  */
 export interface RouteHandlerArgs<TState = undefined> {
     send: SendFn<TState>;
@@ -24,6 +26,8 @@ export interface RouteHandlerArgs<TState = undefined> {
      */
     resolveActiveSession: ResolveActiveSessionFn;
     cancel: CancelFn;
+    clear: ClearFn;
+    compact: CompactFn;
     reset: ResetFn;
     getSession: GetSessionFn;
     /**
@@ -119,6 +123,30 @@ export interface CancelOptions {
  * on the event stream.
  */
 export type CancelFn = (options: CancelOptions) => Promise<CancelTurnResult>;
+/** Options for {@link CompactFn}. */
+export interface CompactOptions {
+    /** Channel-local raw token, in the same format accepted by {@link SendFn}. */
+    readonly continuationToken: string;
+}
+/**
+ * Queues context compaction for the session owning a continuation token.
+ * Never sends model input or starts a new session. An accepted request returns
+ * to `session.waiting`; successful compaction emits `compaction.requested`
+ * followed by `compaction.completed` on the session stream.
+ */
+export type CompactFn = (options: CompactOptions) => Promise<CompactSessionResult>;
+/** Options for {@link ClearFn}. */
+export interface ClearOptions {
+    /** Channel-local raw token, in the same format accepted by {@link SendFn}. */
+    readonly continuationToken: string;
+}
+/**
+ * Queues removal of the model-message history for the session owning a
+ * continuation token. Preserves the session, agent configuration, durable
+ * state, limits, and sandbox. Completion is `context.cleared` followed by
+ * `session.waiting` on the session stream.
+ */
+export type ClearFn = (options: ClearOptions) => Promise<ClearSessionResult>;
 /** Options for {@link ResetFn}. */
 export interface ResetOptions {
     /** Channel-local raw token, in the same format accepted by {@link SendFn}. */

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

@@ -27,6 +27,28 @@ export interface CancelTurnResult {
      */
     readonly reason?: string;
 }
+/** Identifies the continuation hook whose durable session should compact. */
+export interface CompactSessionInput {
+    readonly continuationToken: string;
+}
+/** Result of queueing manual context compaction for a session. */
+export type CompactSessionResult = {
+    readonly status: "accepted";
+    readonly sessionId: string;
+} | {
+    readonly status: "no_active_session";
+};
+/** Identifies the continuation hook whose durable session should clear context. */
+export interface ClearSessionInput {
+    readonly continuationToken: string;
+}
+/** Result of queueing a manual context clear for a session. */
+export type ClearSessionResult = {
+    readonly status: "accepted";
+    readonly sessionId: string;
+} | {
+    readonly status: "no_active_session";
+};
 /** Identifies a session to transition permanently to a terminal state. */
 export interface TerminateSessionInput {
     /** Human-readable reason recorded on the terminal workflow transition. */
@@ -100,6 +122,18 @@ export interface SessionAuthContext {
  * interface: the runtime always writes events itself.
  */
 export type EventEmitFn = (event: UnstampedMessageStreamEvent) => Promise<void>;
+/** Framework-internal caller waiting for one delegated conversation turn. */
+export interface TurnCaller {
+    readonly callId: string;
+    readonly subagentName: string;
+    readonly replyTo: {
+        readonly kind: "hook";
+        readonly token: string;
+    } | {
+        readonly kind: "callback";
+        readonly url: string;
+    };
+}
 /**
  * Base deliver payload crossing the runtime boundary.
  *
@@ -122,12 +156,13 @@ export interface DeliverPayload {
 /**
  * Deliver payload sent through the workflow `resumeHook`.
  *
- * Wraps the raw {@link DeliverPayload} with an optional auth update so
- * deliver-time auth crosses the durable hook boundary without a process-local
- * side-channel.
+ * Wraps the raw {@link DeliverPayload} with optional auth and turn-caller
+ * metadata so both cross the durable hook boundary outside adapter-owned data.
  */
 export interface DeliverHookPayload {
     readonly auth?: SessionAuthContext | null;
+    /** Delegated caller waiting for this turn's settled result. */
+    readonly caller?: TurnCaller;
     /** Inbound channel request id used only for workflow attributes. */
     readonly requestId?: string;
     readonly kind: "deliver";
@@ -137,6 +172,14 @@ export interface DeliverHookPayload {
 export interface SessionTimeoutHookPayload {
     readonly kind: "session-timeout";
 }
+/** Requests a context compaction without delivering model input. */
+export interface CompactSessionHookPayload {
+    readonly kind: "compact";
+}
+/** Requests a context clear without delivering model input. */
+export interface ClearSessionHookPayload {
+    readonly kind: "clear";
+}
 /**
  * Runtime-action results resumed back into a parked parent workflow.
  */
@@ -192,13 +235,15 @@ export interface SubagentAuthorizationEventHookPayload {
 /**
  * Serializable payload sent through the workflow `resumeHook`.
  */
-export type HookPayload = DeliverHookPayload | RuntimeActionResultHookPayload | SessionTimeoutHookPayload | SubagentAuthorizationEventHookPayload | SubagentInputRequestHookPayload;
+export type HookPayload = ClearSessionHookPayload | CompactSessionHookPayload | DeliverHookPayload | RuntimeActionResultHookPayload | SessionTimeoutHookPayload | SubagentAuthorizationEventHookPayload | SubagentInputRequestHookPayload;
 /**
- * Terminal callback metadata attached to a session at creation.
+ * Initial caller callback attached to a delegated session at creation.
  *
  * `url` is the absolute callback endpoint. `token` is the capability token
  * embedded in the framework-owned callback route. `callId` and `subagentName`
- * correlate the callee's terminal callback to the pending parent tool call.
+ * correlate the callee's result to the pending tool call. Task sessions send a
+ * terminal session result. Conversation sessions use this as their first turn's
+ * caller; each continuation supplies the caller for that turn.
  */
 export interface SessionCallback {
     readonly callId: string;
@@ -265,8 +310,9 @@ export interface RunInput {
      */
     readonly title?: string;
     /**
-     * Optional terminal callback. When present, the runtime posts a single
-     * callback when the session completes or fails.
+     * Optional caller callback. Task sessions post when the session completes or
+     * fails. Conversation sessions use it for the first turn; continuations carry
+     * the caller for their own turn.
      */
     readonly callback?: SessionCallback;
     /**
@@ -312,12 +358,14 @@ export interface RunInput {
 }
 export interface DeliverInput {
     /**
-     * Authenticated caller principal for this follow-up message.
+     * Authenticated principal for this follow-up message.
      * May differ from the session initiator when different users send
      * messages to the same session. The runtime updates `AuthKey` from
      * this field before calling the adapter's hooks.
      */
     readonly auth?: SessionAuthContext | null;
+    /** Delegated caller waiting for this turn's settled result. */
+    readonly caller?: TurnCaller;
     /** Inbound channel request id used to correlate workflow attributes. */
     readonly requestId?: string;
     readonly continuationToken: string;
@@ -364,6 +412,10 @@ export interface Runtime {
     run(input: RunInput): Promise<RunHandle>;
     /** Requests cancellation of a session's in-flight turn. */
     cancelTurn(input: CancelTurnInput): Promise<CancelTurnResult>;
+    /** Queues context compaction on the session owning a continuation token. */
+    compactSession(input: CompactSessionInput): Promise<CompactSessionResult>;
+    /** Queues a context clear on the session owning a continuation token. */
+    clearSession(input: ClearSessionInput): Promise<ClearSessionResult>;
     /** Terminally retires a session and releases its non-retained continuation hooks. */
     terminateSession(input: TerminateSessionInput): Promise<TerminateSessionResult>;
     /**

package/dist/src/chunks/{use-eve-agent-DaH3cf8K.js → use-eve-agent-BXMIf5fR.js}

@@ -7,6 +7,8 @@ const EVE_HEALTH_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/health`;
 const EVE_INFO_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/info`;
 const EVE_CREATE_SESSION_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/session`;
 const EVE_RESET_SESSION_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/session/reset`;
+const EVE_COMPACT_SESSION_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/session/compact`;
+const EVE_CLEAR_SESSION_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/session/clear`;
 const EVE_CONTINUE_SESSION_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/session/:sessionId`;
 const EVE_MESSAGE_STREAM_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/session/:sessionId/stream`;
 const EVE_CANCEL_TURN_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/session/:sessionId/cancel`;
@@ -118,7 +120,7 @@ const schedule = entry.extend({
 	markdown: z.string().optional()
 });
 const subagent = entry.extend({
-	description: z.string(),
+	description: z.string().optional(),
 	entryPath: z.string(),
 	nodeId: z.string(),
 	rootPath: z.string(),
@@ -383,6 +385,28 @@ const CancelTurnResponseSchema = z.object({
 	status: z.enum(["accepted", "no_active_turn"])
 });
 
+//#endregion
+//#region src/protocol/clear-session.ts
+const ClearResponseSchema = z.discriminatedUnion("status", [z.object({
+	ok: z.literal(true),
+	sessionId: z.string().min(1),
+	status: z.literal("accepted")
+}), z.object({
+	ok: z.literal(true),
+	status: z.literal("no_active_session")
+})]);
+
+//#endregion
+//#region src/protocol/compact-session.ts
+const CompactResponseSchema = z.discriminatedUnion("status", [z.object({
+	ok: z.literal(true),
+	sessionId: z.string().min(1),
+	status: z.literal("accepted")
+}), z.object({
+	ok: z.literal(true),
+	status: z.literal("no_active_session")
+})]);
+
 //#endregion
 //#region src/protocol/reset-session.ts
 const ResetResponseSchema = z.discriminatedUnion("status", [z.object({
@@ -679,6 +703,7 @@ async function openStreamBody(input) {
 		let response;
 		try {
 			response = await fetch(url, {
+				cache: "no-store",
 				headers,
 				redirect: input.redirect,
 				signal: input.signal ?? null
@@ -810,6 +835,33 @@ var ClientSession = class {
 	get state() {
 		return this.#state;
 	}
+	async snapshot(options) {
+		options?.signal?.throwIfAborted();
+		const initialState = this.#state;
+		const sessionId = initialState.sessionId;
+		if (!sessionId) throw new Error("Session has no session ID. Send a message first.");
+		const events = [];
+		for await (const event of this.#readStream({
+			follow: false,
+			sessionId,
+			signal: options?.signal,
+			startIndex: 0
+		})) events.push(event);
+		options?.signal?.throwIfAborted();
+		const lastEvent = events.at(-1);
+		const continuationToken = lastEvent?.type === "session.waiting" ? lastEvent.data.continuationToken : lastEvent?.type === "session.completed" && this.#context.preserveCompletedSessions ? initialState.continuationToken : void 0;
+		return {
+			events,
+			session: continuationToken === void 0 ? {
+				sessionId,
+				streamIndex: events.length
+			} : {
+				continuationToken,
+				sessionId,
+				streamIndex: events.length
+			}
+		};
+	}
 	async send(input) {
 		const payload = normalizeSendTurnInput(input);
 		const state = this.#state;
@@ -854,6 +906,66 @@ var ClientSession = class {
 			status: result.data.status
 		};
 	}
+	async clear() {
+		const state = this.#state;
+		const continuationToken = state.continuationToken;
+		if (continuationToken === void 0) {
+			if (state.sessionId !== void 0) throw new Error("Session has no continuation token. Consume its event stream before clearing.");
+			return { status: "no_active_session" };
+		}
+		const url = createClientUrl(this.#context.host, EVE_CLEAR_SESSION_ROUTE_PATH);
+		const headers = await this.#context.resolveHeaders();
+		headers.set("content-type", "application/json");
+		const response = await fetch(url, withRedirectPolicy$1({
+			body: JSON.stringify({ continuationToken }),
+			headers,
+			method: "POST"
+		}, this.#context.redirect));
+		const body = await response.text();
+		if (!response.ok) throw new ClientError(response.status, body, response.headers);
+		let payload;
+		try {
+			payload = JSON.parse(body);
+		} catch {
+			throw new Error(`Clear route returned invalid JSON (${response.status}).`);
+		}
+		const result = ClearResponseSchema.safeParse(payload);
+		if (!result.success || result.data.status === "accepted" && state.sessionId !== void 0 && result.data.sessionId !== state.sessionId) throw new Error(`Clear route returned an invalid response (${response.status}).`);
+		return result.data.status === "accepted" ? {
+			sessionId: result.data.sessionId,
+			status: "accepted"
+		} : { status: "no_active_session" };
+	}
+	async compact() {
+		const state = this.#state;
+		const continuationToken = state.continuationToken;
+		if (continuationToken === void 0) {
+			if (state.sessionId !== void 0) throw new Error("Session has no continuation token. Consume its event stream before compacting.");
+			return { status: "no_active_session" };
+		}
+		const url = createClientUrl(this.#context.host, EVE_COMPACT_SESSION_ROUTE_PATH);
+		const headers = await this.#context.resolveHeaders();
+		headers.set("content-type", "application/json");
+		const response = await fetch(url, withRedirectPolicy$1({
+			body: JSON.stringify({ continuationToken }),
+			headers,
+			method: "POST"
+		}, this.#context.redirect));
+		const body = await response.text();
+		if (!response.ok) throw new ClientError(response.status, body, response.headers);
+		let payload;
+		try {
+			payload = JSON.parse(body);
+		} catch {
+			throw new Error(`Compact route returned invalid JSON (${response.status}).`);
+		}
+		const result = CompactResponseSchema.safeParse(payload);
+		if (!result.success || result.data.status === "accepted" && state.sessionId !== void 0 && result.data.sessionId !== state.sessionId) throw new Error(`Compact route returned an invalid response (${response.status}).`);
+		return result.data.status === "accepted" ? {
+			sessionId: result.data.sessionId,
+			status: "accepted"
+		} : { status: "no_active_session" };
+	}
 	async reset() {
 		const state = this.#state;
 		const continuationToken = state.continuationToken;
@@ -923,10 +1035,8 @@ var ClientSession = class {
 	async *#createEventStream(sessionId, continuationToken, initialState, input) {
 		const events = [];
 		try {
-			for await (const event of followStreamIterable({
-				host: this.#context.host,
-				resolveHeaders: () => this.#context.resolveHeaders(input.headers),
-				redirect: this.#context.redirect,
+			for await (const event of this.#readStream({
+				headers: input.headers,
 				streamReconnectPolicy: input.streamReconnectPolicy,
 				sessionId,
 				signal: input.signal,
@@ -951,15 +1061,12 @@ var ClientSession = class {
 		const streamIndex = options?.startIndex ?? initialState.streamIndex;
 		const events = [];
 		try {
-			for await (const event of followStreamIterable({
+			for await (const event of this.#readStream({
 				follow: options?.follow,
-				host: this.#context.host,
-				resolveHeaders: () => this.#context.resolveHeaders(),
-				redirect: this.#context.redirect,
-				streamReconnectPolicy: options?.streamReconnectPolicy,
 				sessionId,
 				signal: options?.signal,
-				startIndex: streamIndex
+				startIndex: streamIndex,
+				streamReconnectPolicy: options?.streamReconnectPolicy
 			})) {
 				events.push(event);
 				yield event;
@@ -978,6 +1085,18 @@ var ClientSession = class {
 			});
 		}
 	}
+	#readStream(input) {
+		return followStreamIterable({
+			follow: input.follow,
+			host: this.#context.host,
+			resolveHeaders: () => this.#context.resolveHeaders(input.headers),
+			redirect: this.#context.redirect,
+			streamReconnectPolicy: input.streamReconnectPolicy,
+			sessionId: input.sessionId,
+			signal: input.signal,
+			startIndex: input.startIndex
+		});
+	}
 };
 async function postTurnWithRetry(input) {
 	const attempts = input.mustDeliver ? DELIVER_RETRY_ATTEMPTS : 1;