eve 0.68.0 → 0.70.0

package/dist/src/client/agent-info-schema.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";const owner=z.discriminatedUnion(`kind`,[z.object({kind:z.literal(`application`)}).strict(),z.object({feature:z.string(),kind:z.literal(`framework`)}).strict(),z.object({kind:z.literal(`extension`),namespace:z.string(),packageName:z.string()}).strict()]),moduleBacking=z.discriminatedUnion(`kind`,[z.object({externalDependencies:z.array(z.string()),extensionScope:z.object({namespace:z.string(),sourceRoot:z.string()}).strict().optional(),kind:z.literal(`filesystem`),sourcePath:z.string()}).strict(),z.object({dependencies:z.record(z.string(),z.string()).optional(),kind:z.literal(`programmatic`),moduleId:z.string(),parameters:z.record(z.string(),z.unknown()).optional(),registryId:z.string(),revision:z.string(),semanticRevision:z.string().optional()}).strict()]),binding=z.object({backing:moduleBacking,logicalPath:z.string(),owner}).strict(),source=z.object({binding:binding.optional(),exportName:z.string().optional(),logicalPath:z.string(),owner,sourceId:z.string(),sourceKind:z.enum([`markdown`,`module`,`skill-package`])}).strict(),entry=source.extend({name:z.string()}).strict(),dynamicResolver=source.extend({eventNames:z.array(z.string()),slug:z.string()}).strict(),modelRouting=z.discriminatedUnion(`kind`,[z.object({kind:z.literal(`gateway`),target:z.string(),byok:z.string().optional()}).strict(),z.object({kind:z.literal(`external`),provider:z.string()}).strict()]),modelEndpoint=z.union([z.object({kind:z.literal(`external`),provider:z.string()}).strict(),z.object({kind:z.literal(`chatgpt`),state:z.enum([`checking`,`ready`,`signed-out`,`reauth-required`,`unavailable`]),accountLabel:z.string().optional()}).strict(),z.object({kind:z.literal(`gateway`),connected:z.literal(!0),credential:z.enum([`api-key`,`oidc`,`oauth`]),team:z.optional(z.string())}).strict(),z.object({kind:z.literal(`gateway`),connected:z.literal(!1)}).strict()]),modelBaseFields={contextWindowTokens:z.number().optional(),providerOptions:z.unknown().optional(),reasoning:z.enum([`provider-default`,`none`,`minimal`,`low`,`medium`,`high`,`xhigh`]).optional().catch(void 0),source:source.optional()},agentModel=z.union([z.object({...modelBaseFields,endpoint:modelEndpoint.optional(),id:z.string(),routing:modelRouting}).strict(),z.object({...modelBaseFields,endpoint:z.never().optional(),id:z.never().optional(),routing:z.object({kind:z.literal(`dynamic`),resolver:dynamicResolver}).strict()}).strict()]),tool=entry.extend({description:z.string(),hasAuth:z.boolean(),hasExecute:z.boolean(),hasModelOutputProjection:z.boolean(),hasOutputSchema:z.boolean(),inputSchema:z.unknown(),outputSchema:z.unknown().optional(),requiresApproval:z.boolean()}).strict(),skill=entry.extend({description:z.string(),license:z.string().optional(),markdown:z.string(),metadata:z.record(z.string(),z.string()).optional()}).strict(),instructions=entry.extend({content:z.string(),role:z.enum([`system`,`user`])}).strict(),schedule=entry.extend({cron:z.string(),hasRun:z.boolean(),markdown:z.string().optional()}).strict(),channelMethod=z.enum([`GET`,`HEAD`,`POST`,`PUT`,`PATCH`,`DELETE`,`OPTIONS`,`WEBSOCKET`]),channelRoute=entry.extend({adapterKind:z.string().optional(),method:channelMethod,urlPath:z.string()}).strict(),sourceDescriptor=z.object({backing:z.union([moduleBacking,z.object({kind:z.literal(`resource`),sourcePath:z.string()}).strict()]),form:z.enum([`derived`,`direct`]),layer:z.enum([`framework-default`,`extension-package`,`extension-override`,`application`]),logicalPath:z.string(),owner,sourceId:z.string()}).strict(),shadowedChannelRoute=z.object({method:channelMethod,source:sourceDescriptor,urlPath:z.string(),winnerSourceId:z.string()}).strict(),connection=source.extend({connectionName:z.string(),description:z.string(),hasApproval:z.boolean(),hasAuthorization:z.boolean(),hasHeaders:z.boolean(),protocol:z.string(),toolFilter:z.unknown().optional(),url:z.string()}).strict(),hook=source.extend({eventNames:z.array(z.string()),slug:z.string()}).strict(),memory=source.extend({description:z.string().optional(),slot:z.string(),visibility:z.enum([`scope`,`session`])}).strict(),sandbox=source.extend({provider:z.string().optional(),environmentExportName:z.string().optional(),revisionHash:z.string()}).strict(),subagent=entry.extend({configResolver:dynamicResolver.optional(),description:z.string().optional(),entryPath:z.string(),nodeId:z.string(),parentNodeId:z.string(),rootPath:z.string(),summary:z.object({channels:z.number(),connections:z.number(),hooks:z.number(),instructions:z.number(),memories:z.number(),schedules:z.number(),skills:z.number(),tools:z.number()}).strict()}).strict(),remoteAgent=entry.extend({description:z.string(),nodeId:z.string(),parentNodeId:z.string(),url:z.string().optional()}).strict(),kernelEffect=z.object({action:z.enum([`subagent-call`,`task-cancel`,`workflow-tool-call`]).optional(),audience:z.array(z.enum([`root-session`,`delegated-task-child`])),kind:z.enum([`dispatch`,`provider-tool`]),sourceId:z.string()}).strict(),compositionDiagnostic=z.object({kind:z.enum([`disabled`,`shadowed`]),logicalPath:z.string(),owner,sourceId:z.string(),winnerSourceId:z.string().optional()}).strict(),AgentInfoResultSchema=z.object({agent:z.object({agentRoot:z.string(),appRoot:z.string(),config:source.extend({binding}).strict(),description:z.string().optional(),model:agentModel,name:z.string(),nodeId:z.string(),outputSchema:z.unknown().optional()}).strict(),capabilities:z.object({devRoutes:z.boolean()}).strict(),channels:z.object({routes:z.array(channelRoute),shadowed:z.array(shadowedChannelRoute)}).strict(),composition:z.object({disabled:z.array(compositionDiagnostic),shadowed:z.array(compositionDiagnostic)}).strict(),connections:z.array(connection),diagnostics:z.object({discoveryErrors:z.number(),discoveryWarnings:z.number()}).strict(),hooks:z.array(hook),instructions:z.object({dynamic:z.array(dynamicResolver),static:z.array(instructions)}).strict(),instrumentation:source.optional(),kernelEffects:z.array(kernelEffect),kind:z.literal(`eve-agent-info`),memories:z.array(memory),mode:z.enum([`development`,`production`]),remoteAgents:z.object({entries:z.array(remoteAgent),total:z.number()}).strict(),sandbox,schedules:z.array(schedule),skills:z.object({dynamic:z.array(dynamicResolver),static:z.array(skill)}).strict(),subagents:z.object({local:z.array(subagent),total:z.number()}).strict(),tools:z.object({dynamic:z.array(dynamicResolver),static:z.array(tool)}).strict(),version:z.literal(5),workspace:z.object({resourceRoot:z.unknown(),rootEntries:z.array(z.string())}).strict()}).strict().superRefine((e,t)=>{let assertUnique=(e,n,r)=>{let i=new Set;e.forEach((e,a)=>{let o=n(e);i.has(o)&&t.addIssue({code:`custom`,message:`Duplicate public identity "${o}".`,path:[...r,a]}),i.add(o)})},assertTotal=(e,n,r)=>{(!Number.isSafeInteger(e)||e<0||e!==n.length)&&t.addIssue({code:`custom`,message:`Expected total ${n.length}, received ${e}.`,path:[...r]})};assertUnique(e.tools.static,e=>e.name,[`tools`,`static`]),assertUnique(e.tools.dynamic,e=>e.slug,[`tools`,`dynamic`]),assertUnique(e.skills.static,e=>e.name,[`skills`,`static`]),assertUnique(e.skills.dynamic,e=>e.slug,[`skills`,`dynamic`]),assertUnique(e.instructions.static,e=>e.name,[`instructions`,`static`]),assertUnique(e.instructions.dynamic,e=>e.slug,[`instructions`,`dynamic`]),assertUnique(e.schedules,e=>e.name,[`schedules`]),assertUnique(e.connections,e=>e.connectionName,[`connections`]),assertUnique(e.hooks,e=>e.slug,[`hooks`]),assertUnique(e.memories,e=>e.slot,[`memories`]),assertUnique(e.channels.routes,e=>`${e.method} ${normalizeRoutePattern(e.urlPath)}`,[`channels`,`routes`]),assertUnique(e.subagents.local,e=>e.nodeId,[`subagents`,`local`]),assertUnique(e.remoteAgents.entries,e=>e.nodeId,[`remoteAgents`,`entries`]),assertTotal(e.subagents.total,e.subagents.local,[`subagents`,`total`]),assertTotal(e.remoteAgents.total,e.remoteAgents.entries,[`remoteAgents`,`total`]);let n=[[e.agent.config,[`agent`,`config`]],...e.agent.model.source===void 0?[]:[[e.agent.model.source,[`agent`,`model`,`source`]]],...e.agent.model.routing.kind===`dynamic`?[[e.agent.model.routing.resolver,[`agent`,`model`,`routing`,`resolver`]]]:[],...e.channels.routes.map((e,t)=>[e,[`channels`,`routes`,t]]),...e.connections.map((e,t)=>[e,[`connections`,t]]),...e.hooks.map((e,t)=>[e,[`hooks`,t]]),...e.instructions.dynamic.map((e,t)=>[e,[`instructions`,`dynamic`,t]]),...e.instructions.static.map((e,t)=>[e,[`instructions`,`static`,t]]),...e.memories.map((e,t)=>[e,[`memories`,t]]),...e.instrumentation===void 0?[]:[[e.instrumentation,[`instrumentation`]]],...e.remoteAgents.entries.map((e,t)=>[e,[`remoteAgents`,`entries`,t]]),...e.schedules.map((e,t)=>[e,[`schedules`,t]]),...e.skills.dynamic.map((e,t)=>[e,[`skills`,`dynamic`,t]]),...e.skills.static.map((e,t)=>[e,[`skills`,`static`,t]]),...e.subagents.local.flatMap((e,t)=>e.configResolver===void 0?[]:[[e.configResolver,[`subagents`,`local`,t,`configResolver`]]]),...e.tools.dynamic.map((e,t)=>[e,[`tools`,`dynamic`,t]]),...e.tools.static.map((e,t)=>[e,[`tools`,`static`,t]]),[e.sandbox,[`sandbox`]]];for(let[e,r]of n){if(e.sourceKind===`module`&&e.binding===void 0){t.addIssue({code:`custom`,message:`Module source is missing its compiled binding.`,path:[...r,`binding`]});continue}if(e.sourceKind!==`module`&&e.binding!==void 0){t.addIssue({code:`custom`,message:`${e.sourceKind} source cannot carry a module binding.`,path:[...r,`binding`]});continue}e.binding!==void 0&&(e.binding.logicalPath!==e.logicalPath&&t.addIssue({code:`custom`,message:`Source and binding logical paths do not match.`,path:[...r,`binding`,`logicalPath`]}),JSON.stringify(e.binding.owner)!==JSON.stringify(e.owner)&&t.addIssue({code:`custom`,message:`Source and binding owners do not match.`,path:[...r,`binding`,`owner`]}))}});function normalizeRoutePattern(e){return e.replace(/^\/+|\/+$/g,``).split(`/`).map(e=>e.startsWith(`:`)||/^\[[^\]]+\]$/.test(e)?`:`:e).join(`/`)}export{AgentInfoResultSchema};
+import{z}from"#compiled/zod/index.js";import{mountIdSchema}from"#shared/extension-mount.js";const owner=z.discriminatedUnion(`kind`,[z.object({kind:z.literal(`application`)}).strict(),z.object({feature:z.string(),kind:z.literal(`framework`)}).strict(),z.object({kind:z.literal(`extension`),mountId:mountIdSchema.optional(),namespace:z.string(),packageName:z.string()}).strict()]),moduleBacking=z.discriminatedUnion(`kind`,[z.object({externalDependencies:z.array(z.string()),extensionScope:z.object({namespace:z.string(),sourceRoot:z.string()}).strict().optional(),kind:z.literal(`filesystem`),mountId:z.string().optional(),sourcePath:z.string()}).strict(),z.object({dependencies:z.record(z.string(),z.string()).optional(),kind:z.literal(`programmatic`),mountId:z.string().optional(),moduleId:z.string(),parameters:z.record(z.string(),z.unknown()).optional(),registryId:z.string(),revision:z.string(),semanticRevision:z.string().optional()}).strict()]),binding=z.object({backing:moduleBacking,logicalPath:z.string(),owner}).strict(),source=z.object({binding:binding.optional(),exportName:z.string().optional(),logicalPath:z.string(),owner,sourceId:z.string(),sourceKind:z.enum([`markdown`,`module`,`skill-package`])}).strict(),entry=source.extend({name:z.string()}).strict(),dynamicResolver=source.extend({eventNames:z.array(z.string()),slug:z.string()}).strict(),modelRouting=z.discriminatedUnion(`kind`,[z.object({kind:z.literal(`gateway`),target:z.string(),byok:z.string().optional()}).strict(),z.object({kind:z.literal(`external`),provider:z.string()}).strict()]),modelEndpoint=z.union([z.object({kind:z.literal(`external`),provider:z.string()}).strict(),z.object({kind:z.literal(`chatgpt`),state:z.enum([`checking`,`ready`,`signed-out`,`reauth-required`,`unavailable`]),accountLabel:z.string().optional()}).strict(),z.object({kind:z.literal(`gateway`),connected:z.literal(!0),credential:z.enum([`api-key`,`oidc`,`oauth`]),team:z.optional(z.string())}).strict(),z.object({kind:z.literal(`gateway`),connected:z.literal(!1)}).strict()]),modelBaseFields={contextWindowTokens:z.number().optional(),providerOptions:z.unknown().optional(),reasoning:z.enum([`provider-default`,`none`,`minimal`,`low`,`medium`,`high`,`xhigh`]).optional().catch(void 0),source:source.optional()},agentModel=z.union([z.object({...modelBaseFields,endpoint:modelEndpoint.optional(),id:z.string(),routing:modelRouting}).strict(),z.object({...modelBaseFields,endpoint:z.never().optional(),id:z.never().optional(),routing:z.object({kind:z.literal(`dynamic`),resolver:dynamicResolver}).strict()}).strict()]),tool=entry.extend({description:z.string(),hasAuth:z.boolean(),hasExecute:z.boolean(),hasModelOutputProjection:z.boolean(),hasOutputSchema:z.boolean(),inputSchema:z.unknown(),outputSchema:z.unknown().optional(),requiresApproval:z.boolean()}).strict(),skill=entry.extend({description:z.string(),license:z.string().optional(),markdown:z.string(),metadata:z.record(z.string(),z.string()).optional()}).strict(),instructions=entry.extend({content:z.string(),role:z.enum([`system`,`user`])}).strict(),schedule=entry.extend({cron:z.string(),hasRun:z.boolean(),markdown:z.string().optional()}).strict(),channelMethod=z.enum([`GET`,`HEAD`,`POST`,`PUT`,`PATCH`,`DELETE`,`OPTIONS`,`WEBSOCKET`]),channelRoute=entry.extend({adapterKind:z.string().optional(),method:channelMethod,urlPath:z.string()}).strict(),sourceDescriptor=z.object({backing:z.union([moduleBacking,z.object({kind:z.literal(`resource`),sourcePath:z.string()}).strict()]),form:z.enum([`derived`,`direct`]),layer:z.enum([`framework-default`,`extension-package`,`extension-override`,`application`]),logicalPath:z.string(),owner,sourceId:z.string()}).strict(),shadowedChannelRoute=z.object({method:channelMethod,source:sourceDescriptor,urlPath:z.string(),winnerSourceId:z.string()}).strict(),connection=source.extend({connectionName:z.string(),description:z.string(),hasApproval:z.boolean(),hasAuthorization:z.boolean(),hasHeaders:z.boolean(),protocol:z.string(),toolFilter:z.unknown().optional(),url:z.string()}).strict(),hook=source.extend({eventNames:z.array(z.string()),slug:z.string()}).strict(),memory=source.extend({description:z.string().optional(),slot:z.string(),visibility:z.enum([`scope`,`session`])}).strict(),sandbox=source.extend({provider:z.string().optional(),environmentExportName:z.string().optional(),revisionHash:z.string()}).strict(),subagent=entry.extend({configResolver:dynamicResolver.optional(),description:z.string().optional(),entryPath:z.string(),nodeId:z.string(),parentNodeId:z.string(),rootPath:z.string(),summary:z.object({channels:z.number(),connections:z.number(),hooks:z.number(),instructions:z.number(),memories:z.number(),schedules:z.number(),skills:z.number(),tools:z.number()}).strict()}).strict(),remoteAgent=entry.extend({description:z.string(),nodeId:z.string(),parentNodeId:z.string(),url:z.string().optional()}).strict(),kernelEffect=z.object({action:z.union([z.enum([`subagent-call`,`workflow-tool-call`]),z.literal(`unrecognized`)]).catch(`unrecognized`).optional(),audience:z.array(z.union([z.literal(`root-session`),z.literal(`unrecognized`)]).catch(`unrecognized`)),kind:z.union([z.enum([`dispatch`,`provider-tool`]),z.literal(`unrecognized`)]).catch(`unrecognized`),sourceId:z.string()}).strict(),compositionDiagnostic=z.object({kind:z.enum([`disabled`,`shadowed`]),logicalPath:z.string(),owner,sourceId:z.string(),winnerSourceId:z.string().optional()}).strict(),AgentInfoResultSchema=z.object({agent:z.object({agentRoot:z.string(),appRoot:z.string(),config:source.extend({binding}).strict(),description:z.string().optional(),model:agentModel,name:z.string(),nodeId:z.string(),outputSchema:z.unknown().optional()}).strict(),capabilities:z.object({devRoutes:z.boolean()}).strict(),channels:z.object({routes:z.array(channelRoute),shadowed:z.array(shadowedChannelRoute)}).strict(),composition:z.object({disabled:z.array(compositionDiagnostic),shadowed:z.array(compositionDiagnostic)}).strict(),connections:z.array(connection),diagnostics:z.object({discoveryErrors:z.number(),discoveryWarnings:z.number()}).strict(),hooks:z.array(hook),instructions:z.object({dynamic:z.array(dynamicResolver),static:z.array(instructions)}).strict(),instrumentation:source.optional(),kernelEffects:z.array(kernelEffect),kind:z.literal(`eve-agent-info`),memories:z.array(memory),mode:z.enum([`development`,`production`]),remoteAgents:z.object({entries:z.array(remoteAgent),total:z.number()}).strict(),sandbox,schedules:z.array(schedule),skills:z.object({dynamic:z.array(dynamicResolver),static:z.array(skill)}).strict(),subagents:z.object({local:z.array(subagent),total:z.number()}).strict(),tools:z.object({dynamic:z.array(dynamicResolver),static:z.array(tool)}).strict(),version:z.literal(5),workspace:z.object({resourceRoot:z.unknown(),rootEntries:z.array(z.string())}).strict()}).strict().superRefine((e,t)=>{let assertUnique=(e,n,r)=>{let i=new Set;e.forEach((e,a)=>{let o=n(e);i.has(o)&&t.addIssue({code:`custom`,message:`Duplicate public identity "${o}".`,path:[...r,a]}),i.add(o)})},assertTotal=(e,n,r)=>{(!Number.isSafeInteger(e)||e<0||e!==n.length)&&t.addIssue({code:`custom`,message:`Expected total ${n.length}, received ${e}.`,path:[...r]})};assertUnique(e.tools.static,e=>e.name,[`tools`,`static`]),assertUnique(e.tools.dynamic,e=>e.slug,[`tools`,`dynamic`]),assertUnique(e.skills.static,e=>e.name,[`skills`,`static`]),assertUnique(e.skills.dynamic,e=>e.slug,[`skills`,`dynamic`]),assertUnique(e.instructions.static,e=>e.name,[`instructions`,`static`]),assertUnique(e.instructions.dynamic,e=>e.slug,[`instructions`,`dynamic`]),assertUnique(e.schedules,e=>e.name,[`schedules`]),assertUnique(e.connections,e=>e.connectionName,[`connections`]),assertUnique(e.hooks,e=>e.slug,[`hooks`]),assertUnique(e.memories,e=>e.slot,[`memories`]),assertUnique(e.channels.routes,e=>`${e.method} ${normalizeRoutePattern(e.urlPath)}`,[`channels`,`routes`]),assertUnique(e.subagents.local,e=>e.nodeId,[`subagents`,`local`]),assertUnique(e.remoteAgents.entries,e=>e.nodeId,[`remoteAgents`,`entries`]),assertTotal(e.subagents.total,e.subagents.local,[`subagents`,`total`]),assertTotal(e.remoteAgents.total,e.remoteAgents.entries,[`remoteAgents`,`total`]);let n=[[e.agent.config,[`agent`,`config`]],...e.agent.model.source===void 0?[]:[[e.agent.model.source,[`agent`,`model`,`source`]]],...e.agent.model.routing.kind===`dynamic`?[[e.agent.model.routing.resolver,[`agent`,`model`,`routing`,`resolver`]]]:[],...e.channels.routes.map((e,t)=>[e,[`channels`,`routes`,t]]),...e.connections.map((e,t)=>[e,[`connections`,t]]),...e.hooks.map((e,t)=>[e,[`hooks`,t]]),...e.instructions.dynamic.map((e,t)=>[e,[`instructions`,`dynamic`,t]]),...e.instructions.static.map((e,t)=>[e,[`instructions`,`static`,t]]),...e.memories.map((e,t)=>[e,[`memories`,t]]),...e.instrumentation===void 0?[]:[[e.instrumentation,[`instrumentation`]]],...e.remoteAgents.entries.map((e,t)=>[e,[`remoteAgents`,`entries`,t]]),...e.schedules.map((e,t)=>[e,[`schedules`,t]]),...e.skills.dynamic.map((e,t)=>[e,[`skills`,`dynamic`,t]]),...e.skills.static.map((e,t)=>[e,[`skills`,`static`,t]]),...e.subagents.local.flatMap((e,t)=>e.configResolver===void 0?[]:[[e.configResolver,[`subagents`,`local`,t,`configResolver`]]]),...e.tools.dynamic.map((e,t)=>[e,[`tools`,`dynamic`,t]]),...e.tools.static.map((e,t)=>[e,[`tools`,`static`,t]]),[e.sandbox,[`sandbox`]]];for(let[e,r]of n){if(e.sourceKind===`module`&&e.binding===void 0){t.addIssue({code:`custom`,message:`Module source is missing its compiled binding.`,path:[...r,`binding`]});continue}if(e.sourceKind!==`module`&&e.binding!==void 0){t.addIssue({code:`custom`,message:`${e.sourceKind} source cannot carry a module binding.`,path:[...r,`binding`]});continue}e.binding!==void 0&&(e.binding.logicalPath!==e.logicalPath&&t.addIssue({code:`custom`,message:`Source and binding logical paths do not match.`,path:[...r,`binding`,`logicalPath`]}),JSON.stringify(e.binding.owner)!==JSON.stringify(e.owner)&&t.addIssue({code:`custom`,message:`Source and binding owners do not match.`,path:[...r,`binding`,`owner`]}))}});function normalizeRoutePattern(e){return e.replace(/^\/+|\/+$/g,``).split(`/`).map(e=>e.startsWith(`:`)||/^\[[^\]]+\]$/.test(e)?`:`:e).join(`/`)}export{AgentInfoResultSchema};

package/dist/src/client/agent-session.d.ts

@@ -0,0 +1,28 @@
+import type { ClientSessionContext } from "#client/session.js";
+import type { StreamOptions } from "#client/types.js";
+import type { AgentStartedStreamEvent, MessageStreamEvent } from "#protocol/message.js";
+/**
+ * A session an agent run opened, reached through the parent session whose
+ * stream announced it with `agent.started`. Get one with
+ * `session.agent(started)`. Every read uses the parent's host and
+ * credentials: a local child's own route, or the parent-origin proxy for a
+ * remote child, which the parent deployment authenticates to the remote agent
+ * after checking that it recorded the child.
+ */
+export declare class ClientAgentSession {
+    #private;
+    /** The agent's name, as `agent.started` reports it. */
+    readonly name: string;
+    /** The child session's id. */
+    readonly sessionId: string;
+    /** The task whose run opened the session; absent when an `execute` call opened it. */
+    readonly taskId: string | undefined;
+    /** @internal */
+    constructor(context: ClientSessionContext, started: AgentStartedStreamEvent);
+    /**
+     * Follows the child's durable event stream. Reading it never advances the
+     * parent session's cursor. The child cursor starts at `0`; pass `startIndex`
+     * to resume. Stop at a child turn boundary with `isCurrentTurnBoundaryEvent`.
+     */
+    stream(options?: StreamOptions): AsyncIterable<MessageStreamEvent>;
+}

package/dist/src/client/agent-session.js

@@ -0,0 +1 @@
+import{followStreamIterable}from"#client/open-stream.js";var ClientAgentSession=class{name;sessionId;taskId;#e;#t;constructor(e,t){this.#e=e,this.#t=t.data.streamPath,this.name=t.data.name,this.sessionId=t.data.sessionId,this.taskId=t.data.taskId}stream(e){let t=e?.startIndex??0;if(e?.follow===!1&&t<0)throw Error(`agent(started).stream({ follow: false }) requires a nonnegative startIndex; a tail-relative cursor cannot be bounded.`);return followStreamIterable({follow:e?.follow,host:this.#e.host,path:this.#t,redirect:this.#e.redirect,resolveHeaders:()=>this.#e.resolveHeaders(),signal:e?.signal,startIndex:t,streamReconnectPolicy:e?.streamReconnectPolicy})}};export{ClientAgentSession};

package/dist/src/client/agent-stream-follower.d.ts

@@ -0,0 +1,26 @@
+import { type ConversationState } from "#client/conversation-state.js";
+import type { ClientSession } from "#client/session.js";
+import type { MessageStreamEvent } from "#protocol/message.js";
+export interface AgentStreamFollowerOptions {
+    /** The session whose stream announced the agents; reads use its host and credentials. */
+    readonly session: ClientSession;
+    readonly getState: () => ConversationState;
+    readonly onFollowing: (sessionId: string) => void;
+    readonly onEvent: (sessionId: string, event: MessageStreamEvent) => void;
+    readonly onIdle: (sessionId: string) => void;
+    readonly onUnavailable: (sessionId: string) => void;
+    /** Retained by the transport owner across detach and reattach. */
+    readonly cursors: Map<string, number>;
+}
+/**
+ * Follows each agent tool's session while its task has content the conversation has not shown.
+ * The conversation decides when a session is caught up; this class only owns transport.
+ */
+export declare class AgentStreamFollower {
+    #private;
+    constructor(options: AgentStreamFollowerOptions);
+    acceptParentEvent(event: MessageStreamEvent): void;
+    /** Starts, resumes, or pauses subscriptions to match the conversation. */
+    reconcile(): void;
+    abortAll(): void;
+}

package/dist/src/client/agent-stream-follower.js

@@ -0,0 +1 @@
+import{agentToolTask,isAgentSessionCaughtUp}from"#client/conversation-state.js";const agentStreamReconnectPolicy={streamIdleReconnectPolicy:{maxAttempts:1/0},streamOpenReconnectPolicy:{maxAttempts:1/0}};var AgentStreamFollower=class{#e;#t=new Map;#n=new Map;#r=new Set;#i=!1;constructor(e){this.#e=e}acceptParentEvent(e){e.type===`agent.started`&&this.#t.set(e.data.sessionId,e)}reconcile(){if(this.#i)return;let e=this.#e.getState();for(let t of Object.values(e.agents)){if(agentToolTask(e,t)===void 0)continue;let n=this.#n.get(t.sessionId),r=isAgentSessionCaughtUp(e,t);n!==void 0&&r?(this.#n.delete(t.sessionId),n.abort(),this.#e.onIdle(t.sessionId)):n===void 0&&!r&&!this.#r.has(t.sessionId)&&this.#a(t.sessionId)}}abortAll(){this.#i=!0;for(let e of this.#n.values())e.abort();this.#n.clear()}#a(e){let t=this.#t.get(e);if(t===void 0)return;let n=new AbortController;this.#n.set(e,n),this.#e.onFollowing(e);let{cursors:r}=this.#e;(async()=>{let i=r.get(e)??0;try{for await(let a of this.#e.session.agent(t).stream({signal:n.signal,startIndex:i,streamReconnectPolicy:agentStreamReconnectPolicy})){if(n.signal.aborted)return;r.set(e,++i),this.#e.onEvent(e,a),this.reconcile()}}catch{}n.signal.aborted||this.#n.get(e)!==n||(this.#n.delete(e),this.#r.add(e),this.#e.onUnavailable(e))})()}};export{AgentStreamFollower};

package/dist/src/client/authorization-message-parts.js

@@ -1 +1 @@
-function createAuthorizationRequiredPart(e){let t=e.data.authorization?.displayName??formatAuthorizationDisplayName(e.data.name);return{authorization:e.data.authorization,description:normalizeAuthorizationDescription(e.data.description,e.data.name,t),displayName:t,name:e.data.name,state:`required`,stepIndex:e.data.stepIndex,turnId:e.data.turnId,type:`authorization`}}function createAuthorizationCompletedPart(e,t){let n=e.data.authorization?.displayName??t?.displayName??formatAuthorizationDisplayName(e.data.name);return{authorization:t?.authorization||e.data.authorization?{...t?.authorization,...e.data.authorization}:void 0,description:t?.description??buildCompletedAuthorizationDescription(n,e.data.outcome,e.data.reason),displayName:n,name:e.data.name,outcome:e.data.outcome,reason:e.data.reason,state:`completed`,stepIndex:t?.stepIndex??e.data.stepIndex,turnId:t?.turnId??e.data.turnId,type:`authorization`}}function buildCompletedAuthorizationDescription(e,t,n){return t===`authorized`?`${e} connected.`:`${e} authorization ${t}${n===void 0?``:` (${n})`}.`}function normalizeAuthorizationDescription(e,t,n){return e===`Authorization required for ${t}`?`Authorization required for ${n}`:e}function formatAuthorizationDisplayName(e){return e.length===0?e:`${e.charAt(0).toUpperCase()}${e.slice(1)}`}export{createAuthorizationCompletedPart,createAuthorizationRequiredPart};
+function createAuthorizationRequiredPart(e){let t=e.data.authorization?.displayName??formatAuthorizationDisplayName(e.data.name),n={authorization:e.data.authorization,description:normalizeAuthorizationDescription(e.data.description,e.data.name,t),displayName:t,name:e.data.name,state:`required`,stepIndex:e.data.stepIndex,turnId:e.data.turnId,type:`authorization`};return e.data.attemptId!==void 0&&(n.attemptId=e.data.attemptId),e.data.webhookUrl!==void 0&&(n.awaitsCallback=!0),n}function createAuthorizationCompletedPart(e,t){let n=e.data.authorization?.displayName??t?.displayName??formatAuthorizationDisplayName(e.data.name),r={authorization:t?.authorization||e.data.authorization?{...t?.authorization,...e.data.authorization}:void 0,description:t?.description??buildCompletedAuthorizationDescription(n,e.data.outcome,e.data.reason),displayName:n,name:e.data.name,outcome:e.data.outcome,state:`completed`,stepIndex:t?.stepIndex??e.data.stepIndex,turnId:t?.turnId??e.data.turnId,type:`authorization`},i=e.data.attemptId??t?.attemptId;return i!==void 0&&(r.attemptId=i),t?.awaitsCallback&&(r.awaitsCallback=!0),e.data.reason!==void 0&&(r.reason=e.data.reason),r}function buildCompletedAuthorizationDescription(e,t,n){return t===`authorized`?`${e} connected.`:`${e} authorization ${t}${n===void 0?``:` (${n})`}.`}function normalizeAuthorizationDescription(e,t,n){return e===`Authorization required for ${t}`?`Authorization required for ${n}`:e}function formatAuthorizationDisplayName(e){return e.length===0?e:`${e.charAt(0).toUpperCase()}${e.slice(1)}`}export{createAuthorizationCompletedPart,createAuthorizationRequiredPart};

package/dist/src/client/conversation-client.d.ts

@@ -0,0 +1,40 @@
+import type { ConversationState } from "#client/conversation-state.js";
+import { EveAgentProjection, type EveAgentEventLog } from "#client/eve-agent-projection.js";
+import type { SendTurnPayload } from "#client/types.js";
+import type { EveAgentReducerEvent } from "#client/reducer.js";
+import type { MessageStreamEvent } from "#protocol/message.js";
+import type { InputResponse } from "#shared/input.js";
+import { SessionEventStream, type SessionEventStreamOptions } from "#client/session-event-stream.js";
+import type { ClientSession } from "#client/session.js";
+/** Owns the canonical conversation and its root and agent-session transports for one client session. */
+export declare class ConversationClient<TData = ConversationState> {
+    #private;
+    readonly projection: EveAgentProjection<TData>;
+    constructor(projection: EveAgentProjection<TData>, onChange: (data: TData, previous: TData) => void, onConversationChange?: (state: ConversationState, previous: ConversationState) => void);
+    get data(): TData;
+    get conversation(): ConversationState;
+    get projections(): readonly EveAgentEventLog[];
+    get following(): boolean;
+    append(event: EveAgentReducerEvent): void;
+    /** Projects submitted answers; the returned callback withdraws them if the server never accepts. */
+    projectResponses(responses: readonly InputResponse[] | undefined): (() => void) | undefined;
+    /** Swaps projected answers for a prepared payload's, which must still be answerable. */
+    replaceResponses(retract: (() => void) | undefined, input: SendTurnPayload): (() => void) | undefined;
+    /** Admit and project a root event before the agent sessions it announces are followed. */
+    observe(event: MessageStreamEvent, options?: {
+        /** The store reconciles optimistic messages instead of directly appending the event. */
+        project?: (event: MessageStreamEvent) => void;
+        /** Record the accepted event before projection or child notifications. */
+        onAccepted?: (event: MessageStreamEvent) => void;
+        /** The store publishes after updating its event log and status. */
+        notify?: boolean;
+    }): boolean;
+    /** Admit and project a hydrated root event without notifying subscribers. */
+    hydrate(event: MessageStreamEvent): boolean;
+    /** Start following the agent sessions the root stream has announced so far. */
+    follow(session: ClientSession, events?: readonly MessageStreamEvent[]): void;
+    /** Follows the root session continuously; operation readers subscribe to this one stream. */
+    stream(session: ClientSession, options: SessionEventStreamOptions): SessionEventStream;
+    stop(): void;
+    reset(): void;
+}

package/dist/src/client/conversation-client.js

@@ -0,0 +1 @@
+import{assertAnswerable}from"#client/eve-agent-store-helpers.js";import{AgentStreamFollower}from"#client/agent-stream-follower.js";import{canonicalConversationReducer,conversationReducer}from"#client/conversation-reducer.js";import{EveAgentProjection}from"#client/eve-agent-projection.js";import{createEventDeduper}from"#protocol/event-dedupe.js";import{SessionEventStream}from"#client/session-event-stream.js";var ConversationClient=class{projection;#e;#t=new Map;#n=createEventDeduper();#r;#i;#a;#o;constructor(e,t,n){this.projection=e,this.#e=e.reducer===conversationReducer?e:new EveAgentProjection(canonicalConversationReducer,[]),this.#a=t,this.#o=n}get data(){return this.projection.data}get conversation(){return this.#e.data}get projections(){return this.#e===this.projection?[this.projection]:[this.#e,this.projection]}get following(){return this.#r!==void 0}append(e){let t=this.data,n=this.conversation;this.#c(e),t===this.data?n!==this.conversation&&this.#o?.(this.conversation,n):this.#a(this.data,t)}projectResponses(e){if(!e?.length)return;let t={data:{createdAt:Date.now(),responses:e},type:`client.input.responded`};return this.append(t),()=>this.#s(t)}replaceResponses(e,t){return e?.(),assertAnswerable(t,this.conversation),this.projectResponses(t.inputResponses)}#s(e){let t=this.data,n=this.conversation;for(let t of this.projections)t.remove(t=>t===e);t===this.data?n!==this.conversation&&this.#o?.(this.conversation,n):this.#a(this.data,t)}observe(e,t={}){if(!this.#n.admit(e))return!1;t.onAccepted?.(e);let n=this.data,r=this.conversation;return t.project?t.project(e):this.#c(e),t.notify!==!1&&(n===this.data?r!==this.conversation&&this.#o?.(this.conversation,r):this.#a(this.data,n)),this.#r?.acceptParentEvent(e),this.#r?.reconcile(),!0}hydrate(e){return this.#n.admit(e)?(this.#c(e),!0):!1}follow(e,t=[]){this.#r?.abortAll();let n=new AgentStreamFollower({session:e,cursors:this.#t,getState:()=>this.conversation,onFollowing:e=>this.#l({type:`client.agent.following`,data:{sessionId:e}}),onEvent:(e,t)=>this.#l({type:`client.agent.observed`,data:{sessionId:e,event:t}}),onIdle:e=>this.#l({type:`client.agent.idle`,data:{sessionId:e}}),onUnavailable:e=>this.#l({type:`client.agent.unavailable`,data:{sessionId:e}})});this.#r=n;for(let e of t)n.acceptParentEvent(e);n.reconcile()}#c(e){for(let t of this.projections)t.append(e)}#l(e){let t=this.data,n=this.conversation;this.#e.append(e),t===this.data?n!==this.conversation&&this.#o?.(this.conversation,n):this.#a(this.data,t)}stream(e,t){return this.#i!==void 0&&!this.#i.ended?(this.#i.setOptions(t),this.#i):(this.#i=new SessionEventStream(e,t),this.#i)}stop(){this.#r?.abortAll(),this.#r=void 0,this.#i?.close(),this.#i=void 0}reset(){this.stop(),this.#t.clear(),this.#n=createEventDeduper();for(let e of this.projections)e.reset()}};export{ConversationClient};

package/dist/src/client/conversation-reducer.d.ts

@@ -0,0 +1,29 @@
+import type { ConversationState } from "#client/conversation-state.js";
+import type { EveAgentReducer, EveAgentReducerEvent } from "#client/reducer.js";
+import type { MessageStreamEvent } from "#protocol/message.js";
+/**
+ * Transport facts about followed agent sessions. Only the canonical conversation receives them;
+ * custom reducers see their results in `conversation.agents`.
+ */
+export type ClientAgentEvent = {
+    readonly data: {
+        readonly sessionId: string;
+    };
+    readonly type: "client.agent.following" | "client.agent.idle" | "client.agent.unavailable";
+} | {
+    readonly data: {
+        readonly event: MessageStreamEvent;
+        readonly sessionId: string;
+    };
+    readonly type: "client.agent.observed";
+};
+export type ConversationEvent = EveAgentReducerEvent | ClientAgentEvent;
+export declare function initialConversationState(): ConversationState;
+/** Pure reduction of accepted root and agent-session observations; followers own transport. */
+export declare function reduceConversation(state: ConversationState, event: ConversationEvent): ConversationState;
+/** The canonical conversation's reducer, which also folds in followed agent sessions. */
+export declare const canonicalConversationReducer: {
+    initial: typeof initialConversationState;
+    reduce: typeof reduceConversation;
+};
+export declare const conversationReducer: EveAgentReducer<ConversationState>;

package/dist/src/client/conversation-reducer.js

@@ -0,0 +1 @@
+import{defaultMessageReducer}from"#client/message-reducer.js";function initialConversationState(){return{messages:[],turns:{},inputs:{},tasks:{},agents:{}}}function updateTurn(e,t,n){let r=e.turns[t];if(r===void 0)return e;let i=n(r);return i===r?e:{...e,turns:{...e.turns,[t]:i}}}function updateTask(e,t,n){let r=e.tasks[t];if(r===void 0)return e;let i=n(r);return i===r?e:{...e,tasks:{...e.tasks,[t]:i}}}function updateObservation(e,t,n){let r=e.agents[t];if(r===void 0)return e;let i=n(r.observation);return i===r.observation?e:{...e,agents:{...e.agents,[t]:{...r,observation:i}}}}function observedConversation(e){return e.status===`not-followed`?void 0:e.conversation}function reduceConversationLifecycle(e,t){switch(t.type){case`turn.started`:return{...e,activeTurnId:t.data.turnId,turns:{...e.turns,[t.data.turnId]:{turnId:t.data.turnId,status:`active`}}};case`turn.waiting`:return updateTurn(e,t.data.turnId,e=>e.status===`active`&&!e.waiting?{...e,waiting:!0}:e);case`step.started`:return updateTurn(e,t.data.turnId,e=>e.waiting?{turnId:e.turnId,status:e.status}:e);case`turn.completed`:case`turn.cancelled`:case`turn.failed`:{let{turnId:n}=t.data;return{...e,activeTurnId:e.activeTurnId===n?void 0:e.activeTurnId,turns:{...e.turns,[n]:{turnId:n,status:t.type===`turn.completed`?`completed`:t.type===`turn.failed`?`failed`:`cancelled`}}}}case`session.waiting`:case`session.completed`:case`session.failed`:return e.activeTurnId===void 0?e:{...e,activeTurnId:void 0};case`task.started`:{let{callId:n,kind:r,name:i,taskId:a,turnId:o}=t.data,s=e.tasks[a]??{taskId:a,name:i,kind:r,calls:{}};return s.calls[n]===void 0?{...e,tasks:{...e.tasks,[a]:{...s,calls:{...s.calls,[n]:{callId:n,turnId:o,status:`working`}}}}}:e}case`task.settled`:{let{callId:n,error:r,output:i,status:a,taskId:o}=t.data;return updateTask(e,o,e=>{let t=e.calls[n];if(t===void 0||t.status!==`working`)return e;let o={callId:n,turnId:t.turnId,status:a};return{...e,calls:{...e.calls,[n]:a===`completed`&&i!==void 0?{...o,output:i}:a===`failed`&&r!==void 0?{...o,error:r}:o}}})}case`agent.started`:{let{callId:n,name:r,sessionId:i,taskId:a,turnId:o}=t.data;if(e.agents[i]!==void 0)return e;let s={sessionId:i,name:r,callId:n,turnId:o,observation:{status:`not-followed`}};return a!==void 0&&(s.taskId=a),{...e,agents:{...e.agents,[i]:s}}}case`input.requested`:{let n={...e.inputs};for(let e of t.data.requests){if(n[e.requestId]!==void 0)continue;let r={request:e,turnId:t.data.turnId,stepIndex:t.data.stepIndex,status:`open`};t.data.taskId!==void 0&&(r.taskId=t.data.taskId),n[e.requestId]=r}return{...e,inputs:n}}case`client.input.responded`:{let n={...e.inputs};for(let e of t.data.responses){let t=n[e.requestId];t?.status===`open`&&(n[e.requestId]={...t,response:e,status:`responded`})}return{...e,inputs:n}}case`approval.candidate`:{let n=e.inputs[t.data.requestId];return n===void 0||n.status===`settled`||t.data.outcome===`pending`?e:{...e,inputs:{...e.inputs,[t.data.requestId]:{...n,status:`open`,response:void 0}}}}case`approval.settled`:{let n=e.inputs[t.data.requestId];return n===void 0||n.status===`settled`?e:{...e,inputs:{...e.inputs,[t.data.requestId]:{...n,status:`settled`,outcome:t.data.outcome}}}}case`input.resolved`:{let n={...e.inputs};for(let e of t.data.resolutions){let t=n[e.requestId];t!==void 0&&t.status!==`settled`&&(n[e.requestId]={...t,status:`settled`,outcome:e.outcome,response:e.response??t.response})}return{...e,inputs:n}}default:return e}}const messageReducer=defaultMessageReducer();function reduceConversation(e,t){switch(t.type){case`client.agent.following`:return updateObservation(e,t.data.sessionId,e=>e.status===`following`?e:{status:`following`,conversation:observedConversation(e)??initialConversationState()});case`client.agent.observed`:return updateObservation(e,t.data.sessionId,e=>e.status===`following`?{status:`following`,conversation:reduceConversation(e.conversation,t.data.event)}:e);case`client.agent.idle`:return updateObservation(e,t.data.sessionId,e=>e.status===`following`?{status:`idle`,conversation:e.conversation}:e);case`client.agent.unavailable`:return updateObservation(e,t.data.sessionId,e=>{let t=observedConversation(e);return t===void 0?{status:`unavailable`}:{status:`unavailable`,conversation:t}});default:{let n=messageReducer.reduce(e,t);return reduceConversationLifecycle({...e,...n},t)}}}const canonicalConversationReducer={initial:initialConversationState,reduce:reduceConversation},conversationReducer=canonicalConversationReducer;export{canonicalConversationReducer,conversationReducer,initialConversationState,reduceConversation};

package/dist/src/client/conversation-state.d.ts

@@ -0,0 +1,110 @@
+import type { EveAuthorizationPart, EveMessageData } from "#client/message-reducer-types.js";
+import type { InputRequest, InputResponse } from "#shared/input.js";
+import type { JsonValue } from "#shared/json.js";
+export interface ConversationTurn {
+    readonly turnId: string;
+    readonly status: "active" | "completed" | "cancelled" | "failed";
+    /** The open turn is parked, holding on its tasks or on a question one of its calls asked. */
+    readonly waiting?: boolean;
+}
+export interface ConversationInput {
+    readonly request: InputRequest;
+    readonly turnId: string;
+    readonly stepIndex: number;
+    /** The task whose run asks, when a task asks. */
+    readonly taskId?: string;
+    readonly status: "open" | "responded" | "settled";
+    readonly response?: InputResponse;
+    readonly outcome?: string;
+}
+/** One call that started or reached a task, settled by its `task.settled`. */
+export interface ConversationTaskCall {
+    readonly callId: string;
+    readonly turnId: string;
+    readonly status: "working" | "completed" | "failed" | "cancelled";
+    /** The call's result; present only when `status` is `"completed"`. */
+    readonly output?: JsonValue;
+    /** Why the call failed; present only when `status` is `"failed"`. */
+    readonly error?: {
+        readonly message: string;
+    };
+}
+export interface ConversationTask {
+    readonly taskId: string;
+    /** The tool whose call started the task. */
+    readonly name: string;
+    /**
+     * `"agent"` when a subagent's tool, local or remote, started the task; `"tool"` for an authored
+     * tool, including one that opens sessions with `ctx.agent`.
+     */
+    readonly kind: "agent" | "tool";
+    /** Calls in the order they started or reached the task. */
+    readonly calls: Readonly<Record<string, ConversationTaskCall>>;
+}
+export type AgentObservation = {
+    readonly status: "not-followed";
+} | {
+    readonly status: "following";
+    readonly conversation: ConversationState;
+}
+/** Every call so far has shown its content; a later call to the task resumes following. */
+ | {
+    readonly status: "idle";
+    readonly conversation: ConversationState;
+} | {
+    /** The stream failed; this does not mean the agent failed. */
+    readonly status: "unavailable";
+    readonly conversation?: ConversationState;
+};
+/** A session a run opened with `ctx.agent`, as its `agent.started` announced it. */
+export interface ConversationAgentSession {
+    readonly sessionId: string;
+    readonly name: string;
+    /** The call whose invocation opened the session. */
+    readonly callId: string;
+    readonly turnId: string;
+    /** The task whose run opened the session; absent when an `execute` call opened it. */
+    readonly taskId?: string;
+    readonly observation: AgentObservation;
+}
+/** Renderable conversation state. Root and agent-session input IDs occupy separate scopes. */
+export interface ConversationState extends EveMessageData {
+    readonly activeTurnId?: string;
+    readonly turns: Readonly<Record<string, ConversationTurn>>;
+    readonly inputs: Readonly<Record<string, ConversationInput>>;
+    readonly tasks: Readonly<Record<string, ConversationTask>>;
+    /** Sessions opened by this session's runs, by session ID. */
+    readonly agents: Readonly<Record<string, ConversationAgentSession>>;
+}
+/** Inputs awaiting an answer, including requests introduced in earlier turns. */
+export declare function openConversationInputs(state: ConversationState): readonly ConversationInput[];
+/** Authorization attempts remain visible across turns, including parked callbacks. */
+export declare function conversationAuthorizations(state: ConversationState): readonly EveAuthorizationPart[];
+/** A sign-in the session still waits on, which resumes its work when the callback arrives. */
+export declare function hasPendingAuthorizations(state: ConversationState): boolean;
+/**
+ * The agent task whose calls a session receives, when the session is that agent's own. eve's agent
+ * tools send each call as one message, in call order, which is what lets a client attribute the
+ * session's turns to calls. A session an authored tool opens with `ctx.agent` has no such task.
+ */
+export declare function agentToolTask(state: ConversationState, agent: ConversationAgentSession): ConversationTask | undefined;
+/** The session an agent tool forwards its task's calls to. */
+export declare function agentToolSession(state: ConversationState, task: ConversationTask): ConversationAgentSession | undefined;
+/**
+ * Whether a followed agent tool session has shown everything its task's calls produced so far:
+ * no call is working, the session has no open turn, question, or sign-in, and every completed call's
+ * message has arrived. The last check covers a child stream that lags the root stream.
+ */
+export declare function isAgentSessionCaughtUp(state: ConversationState, agent: ConversationAgentSession): boolean;
+/**
+ * Attributes an agent tool session's turns to the calls that produced them. The k-th message the
+ * session received came from the task's k-th call; a turn without a message of its own, such as
+ * one resumed after an approval, continues the previous call. A call whose message joined a
+ * running turn owns no turn.
+ */
+export declare function agentCallTurns(task: ConversationTask, conversation: ConversationState): ReadonlyMap<string, readonly string[]>;
+/**
+ * Whether a call's content may still arrive on its agent tool session: one of the call's turns is
+ * still open there, or the call completed before its message reached the session.
+ */
+export declare function isAgentCallContentPending(task: ConversationTask, call: ConversationTaskCall, conversation: ConversationState): boolean;

package/dist/src/client/conversation-state.js

@@ -0,0 +1 @@
+function openConversationInputs(e){return Object.values(e.inputs).filter(e=>e.status===`open`)}function conversationAuthorizations(e){return e.messages.flatMap(e=>e.role===`assistant`?e.parts.filter(e=>e.type===`authorization`):[])}function hasPendingAuthorizations(e){return conversationAuthorizations(e).some(e=>e.state===`required`&&e.awaitsCallback===!0)}function agentToolTask(e,t){let n=t.taskId===void 0?void 0:e.tasks[t.taskId];return n?.kind===`agent`?n:void 0}function agentToolSession(e,t){return Object.values(e.agents).find(n=>agentToolTask(e,n)?.taskId===t.taskId)}function isAgentSessionCaughtUp(e,t){if(t.observation.status!==`following`&&t.observation.status!==`idle`)return!1;let n=agentToolTask(e,t);if(n===void 0)return!1;let r=Object.values(n.calls);if(r.some(e=>e.status===`working`))return!1;let i=t.observation.conversation;return i.activeTurnId!==void 0||Object.values(i.inputs).some(e=>e.status!==`settled`)||hasPendingAuthorizations(i)?!1:i.messages.filter(e=>e.role===`user`).length>=r.filter(e=>e.status===`completed`).length}function agentCallTurns(e,t){let n=Object.keys(e.calls),r=new Map,i=0;for(let e of t.messages){if(e.role!==`user`)continue;let t=n[i++],a=e.metadata?.turnId;t!==void 0&&a!==void 0&&!r.has(a)&&r.set(a,t)}let a=new Map(n.map(e=>[e,[]])),o;for(let e of Object.keys(t.turns))o=r.get(e)??o,o!==void 0&&a.get(o)?.push(e);return a}function isAgentCallContentPending(e,t,n){let r=agentCallTurns(e,n).get(t.callId)??[],{activeTurnId:i}=n;return i!==void 0&&r.includes(i)?!0:t.status===`completed`&&n.messages.filter(e=>e.role===`user`).length<=Object.keys(e.calls).indexOf(t.callId)}export{agentCallTurns,agentToolSession,agentToolTask,conversationAuthorizations,hasPendingAuthorizations,isAgentCallContentPending,isAgentSessionCaughtUp,openConversationInputs};

package/dist/src/client/eve-agent-projection.d.ts

@@ -1,11 +1,28 @@
-import type { EveAgentReducer, EveAgentReducerEvent } from "#client/reducer.js";
-/** Owns reducer replay when optimistic events are replaced by server events. */
-export declare class EveAgentProjection<TData> {
+import type { ConversationEvent } from "#client/conversation-reducer.js";
+import type { EveAgentReducerEvent } from "#client/reducer.js";
+interface ProjectionReducer<TData, TEvent> {
+    initial(): TData;
+    reduce(data: TData, event: TEvent): TData;
+}
+/**
+ * The part of a projection that root-stream bookkeeping writes. Its entries can include the
+ * canonical conversation's agent-session events, so predicates see the wider event type.
+ */
+export interface EveAgentEventLog {
+    append(event: EveAgentReducerEvent): void;
+    remove(predicate: (event: ConversationEvent) => boolean): void;
+    replace(predicate: (event: ConversationEvent) => boolean, replacement: EveAgentReducerEvent): void;
+    reset(): void;
+}
+/** Owns chronological reducer replay when optimistic events are replaced by server events. */
+export declare class EveAgentProjection<TData, TEvent = EveAgentReducerEvent> {
     #private;
-    constructor(reducer: EveAgentReducer<TData>, events: readonly EveAgentReducerEvent[]);
+    constructor(reducer: ProjectionReducer<TData, TEvent>, events: readonly TEvent[]);
     get data(): TData;
+    get reducer(): ProjectionReducer<TData, TEvent>;
     reset(): void;
-    append(event: EveAgentReducerEvent): void;
-    remove(predicate: (event: EveAgentReducerEvent) => boolean): void;
-    replace(predicate: (event: EveAgentReducerEvent) => boolean, replacement: EveAgentReducerEvent): void;
+    append(event: TEvent): void;
+    remove(predicate: (event: TEvent) => boolean): void;
+    replace(predicate: (event: TEvent) => boolean, replacement: TEvent): void;
 }
+export {};

package/dist/src/client/eve-agent-projection.js

@@ -1 +1 @@
-var EveAgentProjection=class{#e;#t;#n;constructor(e,t){this.#e=e,this.#t=t,this.#n=this.#r()}get data(){return this.#n}reset(){this.#t=[],this.#n=this.#e.initial()}append(e){this.#t=[...this.#t,e],this.#n=this.#e.reduce(this.#n,e)}remove(e){this.#t=this.#t.filter(t=>!e(t)),this.#n=this.#r()}replace(e,t){let n=this.#t.findIndex(e);this.#t=n===-1?[...this.#t,t]:this.#t.map((e,r)=>r===n?t:e),this.#n=this.#r()}#r(){let e=this.#e.initial();for(let t of this.#t)e=this.#e.reduce(e,t);return e}};export{EveAgentProjection};
+var EveAgentProjection=class{#e;#t;#n;constructor(e,t){this.#e=e,this.#t=[...t],this.#n=this.#r()}get data(){return this.#n}get reducer(){return this.#e}reset(){this.#t=[],this.#n=this.#e.initial()}append(e){this.#t.push(e),this.#n=this.#e.reduce(this.#n,e)}remove(e){this.#t=this.#t.filter(t=>!e(t)),this.#n=this.#r()}replace(e,t){let n=this.#t.findIndex(e);n===-1?this.#t.push(t):this.#t[n]=t,this.#n=this.#r()}#r(){let e=this.#e.initial();for(let t of this.#t)e=this.#e.reduce(e,t);return e}};export{EveAgentProjection};

package/dist/src/client/eve-agent-store-helpers.d.ts

@@ -1,8 +1,21 @@
+import { type ConversationState } from "#client/conversation-state.js";
 import type { ActiveTurn } from "#client/eve-agent-store-state.js";
 import type { CancelSessionResult, SendTurnPayload } from "#client/types.js";
 import { type MessageStreamEvent } from "#protocol/message.js";
 import type { UserContent } from "ai";
-export declare function isSettledSessionTail(events: readonly MessageStreamEvent[]): boolean;
+export declare function activeTurnForOptimisticFollowUp(events: readonly MessageStreamEvent[]): string | undefined;
+/**
+ * Where catch-up stops following and when an idle session counts as settled. These reads have no
+ * response to scope them, so the {@link endsTurnSegment} rule reads the whole conversation.
+ */
+export declare function isResponseBoundary(event: MessageStreamEvent, conversation: ConversationState): boolean;
+/** A turn parked on a question stays open, so its session is still streaming. */
+export declare function settledStatus(error: Error | undefined, conversation: ConversationState): "error" | "ready" | "streaming";
+export declare function isSettledSessionTail(events: readonly MessageStreamEvent[], conversation: ConversationState): boolean;
+/** A server ignores answers to requests it already settled, so the store never sends them. */
+export declare function assertAnswerable(input: SendTurnPayload, conversation: ConversationState): void;
+export declare function assertInFlightFollowUp(input: SendTurnPayload): void;
+export declare function validateFollowUp<T extends SendTurnPayload>(input: T): T;
 export declare function assertExclusiveTurnInput(input: SendTurnPayload): void;
 export declare function createSubmissionId(): string;
 export declare function createAbortSignal(first: AbortSignal | undefined, second: AbortSignal): AbortSignal;
@@ -10,6 +23,12 @@ export declare function summarizeUserContent(message: string | UserContent): str
 export declare function isAbortError(error: unknown): boolean;
 export declare function toTerminalStreamFailureError(event: MessageStreamEvent): Error | undefined;
 export declare function createActiveTurn(cancel: (turn: ActiveTurn) => Promise<CancelSessionResult>): ActiveTurn;
+/** Counts confirmed steered messages toward the active turn's accepted follow-ups. */
+export declare function countFollowUpDeliveries(turn: ActiveTurn, reconciliation: {
+    readonly alreadyProjected: boolean;
+    readonly event: MessageStreamEvent;
+    readonly ids: readonly string[];
+}): void;
 export declare function followSteeredTurns(turn: ActiveTurn, events: AsyncIterable<MessageStreamEvent>, isActive: () => boolean): Promise<void>;
 /** Aborts a caller's wait without cancelling shared work owned by the store. */
 export declare function waitWithSignal<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T>;

package/dist/src/client/eve-agent-store-helpers.js

@@ -1,2 +1,2 @@
-import{isCurrentTurnBoundaryEvent}from"#protocol/message.js";import{updatePendingAuthorizations}from"#client/session-utils.js";function isSettledSessionTail(e){let t=e.at(-1);return t!==void 0&&isCurrentTurnBoundaryEvent(t)&&(t.type!==`session.waiting`||collectPendingAuthorizations(e).size===0)}function collectPendingAuthorizations(e){let t=new Set;for(let n of e)updatePendingAuthorizations(t,n);return t}function assertExclusiveTurnInput(e){if(e.message!==void 0==(e.inputResponses!==void 0))throw Error(`A turn requires exactly one of message or inputResponses.`)}let submissionSequence=0;function createSubmissionId(){let e=globalThis.crypto?.randomUUID;return e===void 0?(submissionSequence+=1,`submission_${submissionSequence.toString()}`):e.call(globalThis.crypto)}function createAbortSignal(e,t){return e?AbortSignal.any([e,t]):t}function summarizeUserContent(e){if(typeof e==`string`)return e;let t=[];for(let n of e)n.type===`text`?t.push(n.text):n.type===`file`&&t.push(n.filename?`[file: ${n.filename}]`:`[file]`);return t.join(`
-`)}function isAbortError(e){return e instanceof Error&&e.name===`AbortError`}function toTerminalStreamFailureError(e){if(e.type!==`session.failed`)return;let t=Error(e.data.message);return t.name=e.data.code,t}function createActiveTurn(e){let t=Promise.withResolvers(),n=Promise.withResolvers(),r={abortController:new AbortController,acceptedFollowUps:0,cancel:()=>e(r),completion:n.promise,followUpDispatches:new Set,receivedFollowUps:0,receivedFollowUpEvents:new Map,followUpSubmissionIds:new Set,resolveCompletion:n.resolve,response:t.promise,resolveResponse:t.resolve};return r}async function followSteeredTurns(e,t,n){for(;e.followUpDispatches.size>0;)await Promise.allSettled(e.followUpDispatches);if(!(e.receivedFollowUps>=e.acceptedFollowUps))for await(let r of t){if(!n())return;if(e.receivedFollowUps+=e.receivedFollowUpEvents.get(r)??0,e.receivedFollowUpEvents.delete(r),isCurrentTurnBoundaryEvent(r)){for(;e.followUpDispatches.size>0;)await Promise.allSettled(e.followUpDispatches);if(e.receivedFollowUps>=e.acceptedFollowUps)return}}}async function waitWithSignal(e,t){if(t===void 0)return await e;let n=Promise.withResolvers(),onAbort=()=>n.reject(t.reason);t.addEventListener(`abort`,onAbort,{once:!0}),t.aborted&&onAbort();try{return await Promise.race([n.promise,e])}finally{t.removeEventListener(`abort`,onAbort)}}export{assertExclusiveTurnInput,createAbortSignal,createActiveTurn,createSubmissionId,followSteeredTurns,isAbortError,isSettledSessionTail,summarizeUserContent,toTerminalStreamFailureError,waitWithSignal};
+import{hasPendingAuthorizations}from"#client/conversation-state.js";import{TurnSegment,endsTurnSegment}from"#client/session-utils.js";import{isCurrentTurnBoundaryEvent}from"#protocol/message.js";function activeTurnForOptimisticFollowUp(e){let t=e.findLast(e=>e.type===`turn.started`||e.type===`turn.completed`||e.type===`turn.failed`||e.type===`turn.cancelled`||isCurrentTurnBoundaryEvent(e));return t?.type===`turn.started`?t.data.turnId:void 0}function isResponseBoundary(e,t){return endsTurnSegment(e,{callbacks:hasPendingAuthorizations(t),requests:Object.values(t.inputs).some(e=>e.status!==`settled`)})}function settledStatus(e,t){return e===void 0?t.activeTurnId===void 0?`ready`:`streaming`:`error`}function isSettledSessionTail(e,t){let n=e.at(-1);return n!==void 0&&isResponseBoundary(n,t)}function assertAnswerable(e,t){for(let{requestId:n}of e.inputResponses??[]){let e=t.inputs[n]?.status;if(e!==void 0&&e!==`open`)throw Error(`Input request ${n} was already answered.`)}}function assertInFlightFollowUp(e){if(e.inputResponses===void 0&&(e.message===void 0||e.turnPolicy!==`steer`))throw Error(`eve session is already processing a turn. Send a message with turnPolicy: "steer" to guide it at the next boundary, or answer an open input request.`)}function validateFollowUp(e){return assertExclusiveTurnInput(e),assertInFlightFollowUp(e),e}function assertExclusiveTurnInput(e){if(e.message!==void 0==(e.inputResponses!==void 0))throw Error(`A turn requires exactly one of message or inputResponses.`)}let submissionSequence=0;function createSubmissionId(){let e=globalThis.crypto?.randomUUID;return e===void 0?(submissionSequence+=1,`submission_${submissionSequence.toString()}`):e.call(globalThis.crypto)}function createAbortSignal(e,t){return e?AbortSignal.any([e,t]):t}function summarizeUserContent(e){if(typeof e==`string`)return e;let t=[];for(let n of e)n.type===`text`?t.push(n.text):n.type===`file`&&t.push(n.filename?`[file: ${n.filename}]`:`[file]`);return t.join(`
+`)}function isAbortError(e){return e instanceof Error&&e.name===`AbortError`}function toTerminalStreamFailureError(e){if(e.type!==`session.failed`)return;let t=Error(e.data.message);return t.name=e.data.code,t}function createActiveTurn(e){let t=Promise.withResolvers(),n=Promise.withResolvers(),r={abortController:new AbortController,acceptedFollowUps:0,cancel:()=>e(r),completion:n.promise,followUpDispatches:new Set,receivedFollowUps:0,receivedFollowUpEvents:new Map,followUpSubmissionIds:new Set,resolveCompletion:n.resolve,response:t.promise,resolveResponse:t.resolve};return r}function countFollowUpDeliveries(e,t){let n=0;for(let r of t.ids)e.followUpSubmissionIds.delete(r)&&(n+=1);if(n!==0){if(t.alreadyProjected)e.receivedFollowUps+=n;else{let r=e.receivedFollowUpEvents.get(t.event)??0;e.receivedFollowUpEvents.set(t.event,r+n)}}}async function followSteeredTurns(e,t,n){for(;e.followUpDispatches.size>0;)await Promise.allSettled(e.followUpDispatches);if(e.receivedFollowUps>=e.acceptedFollowUps)return;let r=new TurnSegment({followCallbacks:!0});for await(let i of t){if(!n())return;if(e.receivedFollowUps+=e.receivedFollowUpEvents.get(i)??0,e.receivedFollowUpEvents.delete(i),r.observe(i)){for(;e.followUpDispatches.size>0;)await Promise.allSettled(e.followUpDispatches);if(e.receivedFollowUps>=e.acceptedFollowUps)return}}}async function waitWithSignal(e,t){if(t===void 0)return await e;let n=Promise.withResolvers(),onAbort=()=>n.reject(t.reason);t.addEventListener(`abort`,onAbort,{once:!0}),t.aborted&&onAbort();try{return await Promise.race([n.promise,e])}finally{t.removeEventListener(`abort`,onAbort)}}export{activeTurnForOptimisticFollowUp,assertAnswerable,assertExclusiveTurnInput,assertInFlightFollowUp,countFollowUpDeliveries,createAbortSignal,createActiveTurn,createSubmissionId,followSteeredTurns,isAbortError,isResponseBoundary,isSettledSessionTail,settledStatus,summarizeUserContent,toTerminalStreamFailureError,validateFollowUp,waitWithSignal};

package/dist/src/client/eve-agent-store-state.d.ts

@@ -1,5 +1,7 @@
+import type { Client } from "#client/client.js";
 import type { MessageResponse } from "#client/message-response.js";
 import type { EveAgentReducer } from "#client/reducer.js";
+import type { ConversationState } from "#client/conversation-state.js";
 import type { ClientSession } from "#client/session.js";
 import type { MessageStreamEvent } from "#protocol/message.js";
 import type { CancelSessionResult, ClientAuth, ClientSessionState, HeadersValue, SendTurnPayload } from "#client/types.js";
@@ -18,6 +20,8 @@ export type PrepareSend = (input: SendTurnPayload) => SendTurnPayload | Promise<
 /** Immutable projected state of an eve frontend session store. */
 export interface EveAgentStoreSnapshot<TData> {
     readonly data: TData;
+    /** Canonical session facts, independent of the caller's data projection. */
+    readonly conversation: ConversationState;
     /** The latest session creation, stream, resume, or turn failure. */
     readonly error: Error | undefined;
     readonly events: readonly MessageStreamEvent[];
@@ -36,12 +40,14 @@ export interface EveAgentStoreCallbacks<TData> {
     readonly prepareSend?: PrepareSend;
 }
 /**
- * Configuration for constructing an eve frontend session store. Pass either
- * connection options for a store-owned session or an existing `ClientSession`.
- * Saved events must be an ordered prefix of the same session stream.
+ * Configuration for constructing an eve frontend session store. Pass connection
+ * options or a configured `Client` for store-owned sessions, or an existing
+ * `ClientSession`. Saved events must be an ordered prefix of the same session stream.
  */
 export interface EveAgentStoreInit<TData> {
     readonly prewarm?: boolean;
+    /** Configured client for store-owned sessions; replaces `host`, `auth`, and `headers`. */
+    readonly client?: Client;
     readonly auth?: ClientAuth;
     readonly headers?: HeadersValue;
     readonly host?: string;
@@ -49,6 +55,11 @@ export interface EveAgentStoreInit<TData> {
     readonly initialEvents?: readonly MessageStreamEvent[];
     readonly initialSession?: ClientSessionState;
     readonly optimistic?: boolean;
+    /**
+     * Follow each agent tool's session into `conversation.agents`, regardless of the data reducer,
+     * while the store streams its session or a framework binding has it mounted.
+     */
+    readonly followSubagents?: boolean;
     readonly reducer: EveAgentReducer<TData>;
     readonly session?: ClientSession;
 }
@@ -57,6 +68,7 @@ export interface PendingMessageSubmission {
     readonly eventStartIndex: number;
     readonly id: string;
     readonly message: string;
+    readonly turnId?: string;
     readonly requiresDeliveryId: boolean;
     readonly deliveryId?: string;
 }

package/dist/src/client/eve-agent-store.d.ts

@@ -1,5 +1,5 @@
 import type { EveAgentStoreCallbacks, EveAgentStoreInit, EveAgentStoreSnapshot } from "#client/eve-agent-store-state.js";
-import type { CancelSessionResult, SendTurnPayload } from "#client/types.js";
+import type { CancelSessionResult, ClearResult, CompactResult, ResetResult, SendTurnPayload } from "#client/types.js";
 export type { EveAgentStoreCallbacks, EveAgentStoreInit, EveAgentStoreSnapshot, EveAgentStoreStatus, PrepareSend, } from "#client/eve-agent-store-state.js";
 declare const detachStore: unique symbol;
 declare const attachStore: unique symbol;
@@ -26,6 +26,15 @@ export declare class EveAgentStore<TData> {
      * that turn ID. The event stream stays attached until the turn settles.
      */
     cancel(): Promise<CancelSessionResult>;
+    /** Queues server-side compaction of the current session's context. */
+    compact(): Promise<CompactResult>;
+    /** Clears the current session's model-message history on the server. */
+    clear(): Promise<ClearResult>;
+    /**
+     * Terminally retires the store-owned server session, then resets local state so the next
+     * send starts a fresh session. A failed request leaves both intact.
+     */
+    retire(): Promise<ResetResult>;
     [attachStore](): void;
     [detachStore](): void;
     reset(): void;

package/dist/src/client/eve-agent-store.js

@@ -1 +1 @@
-import{toError}from"#shared/errors.js";import{createEventDeduper}from"#protocol/event-dedupe.js";import{isCurrentTurnBoundaryEvent}from"#protocol/message.js";import{updatePendingAuthorizations}from"#client/session-utils.js";import{Client}from"#client/client.js";import{consumeMessageResponse,getMessageResponseDeliveryId}from"#client/message-response.js";import{SessionEventStream}from"#client/session-event-stream.js";import{EveAgentProjection}from"#client/eve-agent-projection.js";import{OptimisticMessageSubmissions}from"#client/optimistic-message-submissions.js";import{assertExclusiveTurnInput,createAbortSignal,createActiveTurn,followSteeredTurns,isAbortError,isSettledSessionTail,toTerminalStreamFailureError,waitWithSignal}from"#client/eve-agent-store-helpers.js";const detachStore=Symbol(`detachEveAgentStore`),attachStore=Symbol(`attachEveAgentStore`);var EveAgentStore=class{#e;#t;#n=!1;#r;#i=new Set;#a;#o;#s;#c=new Set;#l=createEventDeduper();#u;#d={};#f;#p;#m;#h=0;#g;#_;#v;#y;#b;#x=`ready`;constructor(e){this.#t=e.prewarm??!1,this.#a=e.session!==void 0,this.#e=this.#a?void 0:new Client({auth:e.auth,headers:e.headers,host:e.host??``});let t=[];for(let n of e.initialEvents??[])this.#l.admit(n)&&t.push(n),updatePendingAuthorizations(this.#i,n);this.#p=t,this.#s=new EveAgentProjection(e.reducer,this.#p),this.#o=e.optimistic??!0,this.#m=new OptimisticMessageSubmissions(this.#s,this.#o),this.#y=e.session??(e.initialSession===void 0?void 0:this.#e?.sessions.attach(e.initialSession.sessionId,{streamIndex:e.initialSession.streamIndex})),this.#b=this.#P()}get snapshot(){return this.#b}setCallbacks(e){this.#d=e}subscribe(e){return this.#c.add(e),()=>{this.#c.delete(e)}}prewarm(){if(this.#g!==void 0)return this.#g;if(this.#y!==void 0||this.#a)return Promise.resolve();if(this.#u!==void 0)return this.#u.response.then(e=>{if(e===void 0)throw this.#f??new DOMException(`Session creation was aborted.`,`AbortError`)});let e=this.#e;if(e===void 0)return Promise.reject(Error(`This eve agent store does not own a session client.`));let t=this.#h,n=new AbortController;this.#_=n;let r=(async()=>{try{let r=await e.sessions.create({signal:n.signal});if(t!==this.#h)return;this.#y=r.session,this.#f=void 0,this.#x===`error`&&(this.#x=`ready`),this.#d.onSessionChange?.(r.session.state),this.#F(),this.#E()}catch(e){throw t===this.#h&&this.#u===void 0&&this.#f===void 0&&(this.#f=toError(e),this.#x=`error`,this.#d.onError?.(this.#f),this.#F()),e}})();this.#g=r;let clear=()=>{this.#g===r&&(this.#g=void 0,this.#_=void 0)};return r.then(clear,clear),r}async send(e){return await this.#S(e,this.#d.prepareSend)}async#S(e,t){if(this.#u!==void 0){if(this.#x===`resuming`)throw Error(`eve session is resuming.`);return await this.#w(this.#u,e,t)}let n=createActiveTurn(e=>e.acceptedFollowUps>0&&this.#y!==void 0?this.#y.cancel():e.response.then(e=>e===void 0?{status:`no_active_turn`}:e.cancel()));this.#u=n,this.#f=void 0,this.#x=`submitted`,this.#F();let r;try{let i=await(t===void 0?e:waitWithSignal(Promise.resolve(t(e)),createAbortSignal(e.signal,n.abortController.signal)));if(assertExclusiveTurnInput(i),!this.#k(n))return;let a=this.#m.submit(i,this.#p.length);this.#A(i),this.#F();let o={...i,signal:createAbortSignal(i.signal,n.abortController.signal)},s=await this.#T(o),c=s.response;if(r=s.reader,!this.#k(n))return;n.resolveResponse(c),this.#M(this.#m.correlate(a,getMessageResponseDeliveryId(c),this.#p))&&this.#F();for await(let e of consumeMessageResponse(c,r)){if(!this.#k(n))return;n.receivedFollowUps+=n.receivedFollowUpEvents.get(e)??0,n.receivedFollowUpEvents.delete(e)}if(!this.#k(n)||(await followSteeredTurns(n,r,()=>this.#k(n)),!this.#k(n)))return;this.#x=this.#f===void 0?`ready`:`error`}catch(e){if(!this.#k(n))return;if(isAbortError(e))this.#x=`ready`,this.#m.fail(toError(e));else{let t=this.#f!==void 0;this.#f??=toError(e),this.#x=`error`,this.#m.fail(this.#f),t||this.#d.onError?.(this.#f)}}finally{r?.[Symbol.dispose](),this.#O(n)}}resume(){if(this.#v!==void 0)return this.#v;let e=this.#C();this.#v=e;let clear=()=>{this.#v===e&&(this.#v=void 0)};return e.then(clear,clear),e}async#C(){if(this.#x===`resuming`||this.#x===`streaming`||this.#x===`submitted`)throw Error(`eve session is already processing a turn.`);if(this.#y===void 0)throw Error(`An eve session is required before resuming.`);let e=this.#y,t=createActiveTurn(()=>e.cancel());this.#u=t,t.resolveResponse(void 0),this.#f=void 0,this.#x=`resuming`,this.#F();let n;try{let r=this.#E({catchUp:!0,startIndex:this.#p.length===e.state.streamIndex?e.state.streamIndex:0});if(n=r.subscribe(t.abortController.signal),await r.caughtUp,!this.#k(t))return;n.discard();let i=this.#p.at(-1);if(i!==void 0&&this.#N(i),i!==void 0&&this.#f===void 0&&!isSettledSessionTail(this.#p)){this.#x=`streaming`,this.#F();for await(let e of n){if(!this.#k(t))return;if(t.receivedFollowUps+=t.receivedFollowUpEvents.get(e)??0,t.receivedFollowUpEvents.delete(e),isCurrentTurnBoundaryEvent(e)&&this.#i.size===0)break}}await followSteeredTurns(t,n,()=>this.#k(t)),this.#k(t)&&(this.#x=this.#f===void 0?`ready`:`error`)}catch(e){if(!this.#k(t))return;isAbortError(e)?this.#x=`ready`:(this.#f=toError(e),this.#x=`error`,this.#d.onError?.(this.#f))}finally{n?.[Symbol.dispose](),this.#O(t)}}cancel(){let e=this.#u;return e===void 0?this.#x===`streaming`&&this.#y!==void 0?this.#y.cancel():Promise.resolve({status:`no_active_turn`}):e.cancel()}[attachStore](){this.#n=!0,this.#t&&this.#y===void 0&&this.prewarm().catch(()=>{})}[detachStore](){this.#n=!1,this.#r?.close(),this.#r=void 0,this.#u?.abortController.abort(),this.#D(),this.#v=void 0}reset(){this.#r?.close(),this.#r=void 0,this.#i.clear();let e=this.#u;this.#u=void 0,e?.resolveResponse(void 0),e?.resolveCompletion(),e?.abortController.abort(),this.#D(),this.#v=void 0,this.#a||(this.#y=void 0),this.#p=[],this.#l=createEventDeduper(),this.#m.reset(),this.#s.reset(),this.#f=void 0,this.#x=`ready`,this.#d.onSessionChange?.(this.#y?.state),this.#F(),this.#t&&this.#n&&this.prewarm().catch(()=>{})}async#w(e,t,n){if(t.message===void 0||t.turnPolicy!==`steer`)throw Error(`eve session is already processing a turn. Send a message with turnPolicy: "steer" to guide it at the next boundary.`);let r=this.#h,i=createAbortSignal(t.signal,e.abortController.signal),a=await waitWithSignal(Promise.resolve(n?.(t)),i)??t;if(r!==this.#h)return;if(assertExclusiveTurnInput(a),a.message===void 0||a.turnPolicy!==`steer`)throw Error(`An in-flight follow-up requires a message with turnPolicy: "steer".`);if(!this.#k(e))return await this.#S(a);let o=this.#m.submit(a,this.#p.length);o!==void 0&&e.followUpSubmissionIds.add(o),this.#F(),this.#E({headers:a.headers,streamReconnectPolicy:a.streamReconnectPolicy});let s;s=(async()=>{try{let t=createAbortSignal(a.signal,e.abortController.signal);if(await waitWithSignal(e.response,t),!this.#k(e)||this.#y===void 0)throw Error(`The active eve turn ended before the follow-up could be sent.`);let{message:n,...r}=a,i=await this.#y.send(n,{...r,signal:t});e.acceptedFollowUps+=1,this.#M(this.#m.correlate(o,getMessageResponseDeliveryId(i),this.#p))&&this.#F()}catch(t){throw this.#k(e)&&(this.#m.fail(toError(t),o),this.#F()),t}finally{e.followUpDispatches.delete(s)}})(),e.followUpDispatches.add(s),await s,await e.completion}async#T(e){let t={headers:e.headers,streamReconnectPolicy:e.streamReconnectPolicy};if(this.#g!==void 0&&(await waitWithSignal(this.#g.catch(e=>{if(this.#y!==void 0)throw e}),e.signal),e.signal?.throwIfAborted()),this.#y===void 0){if(this.#e===void 0)throw Error(`An external eve session is required before sending.`);if(e.message===void 0)throw Error(`Cannot answer an input request before the session starts.`);let n=await this.#e.sessions.create({...e,message:e.message});return e.signal?.throwIfAborted(),this.#y=n.session,this.#d.onSessionChange?.(n.session.state),this.#F(),{response:n.response,reader:this.#E(t).subscribe(e.signal)}}let n=this.#E(t).subscribe(e.signal);try{if(e.inputResponses===void 0){let{message:t,...r}=e;return{response:await this.#y.send(t,r),reader:n}}let{inputResponses:t,...r}=e;return{response:await this.#y.respond(t,r),reader:n}}catch(e){throw n[Symbol.dispose](),e}}#E(e={}){if(this.#r!==void 0&&!this.#r.ended)return this.#r.setOptions(e),this.#r;if(this.#y===void 0)throw Error(`A session is required before opening its stream.`);let t=this.#y,n=this.#h;return this.#r=new SessionEventStream(t,{...e,onEvent:e=>{n===this.#h&&this.#j(e)},onError:e=>{n===this.#h&&(this.#r=void 0,this.#u===void 0&&(this.#f=toError(e),this.#x=`error`,this.#d.onError?.(this.#f),this.#F()))}}),this.#r}#D(){this.#h+=1,this.#_?.abort(),this.#_=void 0,this.#g=void 0}#O(e){if(this.#k(e)){e.resolveResponse(void 0),this.#u=void 0;try{this.#d.onSessionChange?.(this.#y?.state),this.#F(),this.#d.onFinish?.(this.#b)}finally{e.resolveCompletion()}}}#k(e){return this.#u===e}#A(e){e.inputResponses!==void 0&&e.inputResponses.length!==0&&this.#s.append({data:{createdAt:Date.now(),responses:e.inputResponses},type:`client.input.responded`})}#j(e){if(!this.#l.admit(e))return;let t=this.#x===`streaming`;updatePendingAuthorizations(this.#i,e),this.#p=[...this.#p,e],this.#M(this.#m.apply(e)),this.#d.onEvent?.(e),this.#N(e);let n=isCurrentTurnBoundaryEvent(e)&&this.#i.size===0;this.#x!==`resuming`&&this.#f===void 0&&(`data`in e&&`turnId`in e.data&&(this.#x=`streaming`),this.#u===void 0&&n&&(this.#x=`ready`)),this.#d.onSessionChange?.(this.#y?.state),this.#x!==`resuming`&&this.#F(),this.#u===void 0&&t&&n&&this.#d.onFinish?.(this.#b)}#M(e){if(e===void 0)return!1;let t=0;for(let n of e.ids)this.#u?.followUpSubmissionIds.delete(n)&&(t+=1);if(t>0&&this.#u!==void 0){if(e.alreadyProjected)this.#u.receivedFollowUps+=t;else{let n=this.#u.receivedFollowUpEvents.get(e.event)??0;this.#u.receivedFollowUpEvents.set(e.event,n+t)}}return!0}#N(e){let t=toTerminalStreamFailureError(e);t!==void 0&&(this.#x=`error`,this.#m.failAll(t),this.#f===void 0&&(this.#f=t,this.#d.onError?.(t)))}#P(){return{data:this.#s.data,error:this.#f,events:this.#p,session:this.#y?.state,status:this.#x}}#F(){this.#b=this.#P();for(let e of this.#c)e()}};function detachEveAgentStore(e){e[detachStore]()}function attachEveAgentStore(e){e[attachStore]()}export{EveAgentStore,attachEveAgentStore,detachEveAgentStore};
+import{toError}from"#shared/errors.js";import{activeTurnForOptimisticFollowUp,assertAnswerable,assertExclusiveTurnInput,assertInFlightFollowUp,countFollowUpDeliveries,createAbortSignal,createActiveTurn,followSteeredTurns,isAbortError,isResponseBoundary,isSettledSessionTail,settledStatus,toTerminalStreamFailureError,validateFollowUp,waitWithSignal}from"#client/eve-agent-store-helpers.js";import{EveAgentProjection}from"#client/eve-agent-projection.js";import{Client}from"#client/client.js";import{consumeMessageResponse,getMessageResponseDeliveryId}from"#client/message-response.js";import{OptimisticMessageSubmissions}from"#client/optimistic-message-submissions.js";import{ConversationClient}from"#client/conversation-client.js";import{dispatchSessionTurn}from"#client/session-turn-dispatch.js";const detachStore=Symbol(`detachEveAgentStore`),attachStore=Symbol(`attachEveAgentStore`);var EveAgentStore=class{#e;#t;#n=!1;#r;#i;#a;#o=new Set;#s;#c={};#l;#u;#d;#f=0;#p;#m;#h;#g;#_;#v=`ready`;constructor(e){this.#t=e.prewarm??!1,this.#i=e.followSubagents??!1,this.#a=e.session!==void 0,this.#e=this.#a?void 0:e.client??new Client({auth:e.auth,headers:e.headers,host:e.host??``}),this.#r=new ConversationClient(new EveAgentProjection(e.reducer,[]),()=>this.#F(),()=>this.#F()),this.#u=(e.initialEvents??[]).filter(e=>this.#r.hydrate(e)),this.#d=new OptimisticMessageSubmissions(this.#r.projections,e.optimistic??!0),this.#g=e.session??(e.initialSession===void 0?void 0:this.#e?.sessions.attach(e.initialSession.sessionId,{streamIndex:e.initialSession.streamIndex})),this.#_=this.#P()}get snapshot(){return this.#_}setCallbacks(e){this.#c=e}subscribe(e){return this.#o.add(e),()=>void this.#o.delete(e)}prewarm(){if(this.#p!==void 0)return this.#p;if(this.#g!==void 0||this.#a)return Promise.resolve();if(this.#s!==void 0)return this.#s.response.then(e=>{if(e===void 0)throw this.#l??new DOMException(`Session creation was aborted.`,`AbortError`)});let e=this.#e;if(e===void 0)return Promise.reject(Error(`This eve agent store does not own a session client.`));let t=this.#f,n=new AbortController;this.#m=n;let r=(async()=>{try{let r=await e.sessions.create({signal:n.signal});if(t!==this.#f)return;this.#l=void 0,this.#v===`error`&&(this.#v=`ready`),this.#w(r.session),this.#C()}catch(e){throw t===this.#f&&this.#s===void 0&&this.#l===void 0&&this.#T(e),e}})();this.#p=r;let clear=()=>{this.#p===r&&(this.#p=void 0,this.#m=void 0)};return r.then(clear,clear),r}async send(e){return await this.#y(e,this.#c.prepareSend)}async#y(e,t){if(assertAnswerable(e,this.#r.conversation),this.#s!==void 0){if(this.#v===`resuming`)throw Error(`eve session is resuming.`);return await this.#x(this.#s,e,t)}let n=createActiveTurn(e=>e.acceptedFollowUps>0&&this.#g!==void 0?this.#g.cancel():e.response.then(e=>e===void 0?{status:`no_active_turn`}:e.cancel()));this.#s=n,this.#l=void 0,this.#v=`submitted`;let r,i,a;try{assertExclusiveTurnInput(e),i=this.#d.submit(e,this.#u.length),a=this.#r.projectResponses(e.inputResponses),this.#F();let o=await(t===void 0?e:waitWithSignal(Promise.resolve(t(e)),createAbortSignal(e.signal,n.abortController.signal)));if(assertExclusiveTurnInput(o),!this.#k(n))return;o!==e&&(i=this.#d.resubmit(i,o),a=this.#r.replaceResponses(a,o),this.#F());let s={...o,signal:createAbortSignal(o.signal,n.abortController.signal)},c=await this.#S(s);a=void 0;let l=c.response;if(r=c.reader,!this.#k(n))return;n.resolveResponse(l),this.#j(i,l);for await(let e of consumeMessageResponse(l,r)){if(!this.#k(n))return;n.receivedFollowUps+=n.receivedFollowUpEvents.get(e)??0,n.receivedFollowUpEvents.delete(e)}if(!this.#k(n)||(await followSteeredTurns(n,r,()=>this.#k(n)),!this.#k(n)))return;this.#v=settledStatus(this.#l,this.#r.conversation)}catch(e){if(!this.#k(n))return;if(a?.(),isAbortError(e))this.#v=`ready`,this.#d.fail(toError(e),i);else{let t=this.#l!==void 0;this.#l??=toError(e),this.#v=`error`,this.#d.fail(this.#l,i),t||this.#c.onError?.(this.#l)}}finally{r?.[Symbol.dispose](),this.#O(n)}}resume(){if(this.#h!==void 0)return this.#h;let e=this.#b();this.#h=e;let clear=()=>{this.#h===e&&(this.#h=void 0)};return e.then(clear,clear),e}async#b(){if(this.#v!==`ready`&&this.#v!==`error`)throw Error(`eve session is already processing a turn.`);if(this.#g===void 0)throw Error(`An eve session is required before resuming.`);let e=this.#g,t=createActiveTurn(()=>e.cancel());this.#s=t,t.resolveResponse(void 0),this.#l=void 0,this.#v=`resuming`,this.#F();let n;try{let r=this.#C({catchUp:!0,startIndex:this.#u.length===e.state.streamIndex?e.state.streamIndex:0});if(n=r.subscribe(t.abortController.signal),await r.caughtUp,!this.#k(t))return;n.discard();let i=this.#u.at(-1);if(i!==void 0&&this.#N(i),i&&!this.#l&&!isSettledSessionTail(this.#u,this.#r.conversation)){this.#v=`streaming`,this.#F();for await(let e of n){if(!this.#k(t))return;if(t.receivedFollowUps+=t.receivedFollowUpEvents.get(e)??0,t.receivedFollowUpEvents.delete(e),isResponseBoundary(e,this.#r.conversation))break}}await followSteeredTurns(t,n,()=>this.#k(t)),this.#k(t)&&(this.#v=settledStatus(this.#l,this.#r.conversation))}catch(e){if(!this.#k(t))return;isAbortError(e)?this.#v=`ready`:(this.#l=toError(e),this.#v=`error`,this.#c.onError?.(this.#l))}finally{n?.[Symbol.dispose](),this.#O(t)}}cancel(){let e=this.#s;return e===void 0?this.#v===`streaming`&&this.#g!==void 0?this.#g.cancel():Promise.resolve({status:`no_active_turn`}):e.cancel()}async compact(){return await this.#g?.compact()??{status:`no_active_session`}}async clear(){return await this.#g?.clear()??{status:`no_active_session`}}async retire(){if(this.#a)throw Error(`retire() needs a store-owned session. Call reset() on the session you supplied, then create a new store for the next session.`);let e=await this.#g?.reset()??{status:`no_active_session`};return this.reset(),e}[attachStore](){this.#n=!0,this.#i&&!this.#r.following&&this.#E(),this.#t&&this.#g===void 0&&this.prewarm().catch(()=>{})}[detachStore](){this.#n=!1,this.#r.stop(),this.#s?.abortController.abort(),this.#D(),this.#h=void 0}reset(){this.#r.stop();let e=this.#s;this.#s=void 0,e?.resolveResponse(void 0),e?.resolveCompletion(),e?.abortController.abort(),this.#D(),this.#h=void 0,this.#a||(this.#g=void 0),this.#u=[],this.#r.reset(),this.#d.reset(),this.#i&&this.#n&&this.#E(),this.#l=void 0,this.#v=`ready`,this.#c.onSessionChange?.(this.#g?.state),this.#F(),this.#t&&this.#n&&this.prewarm().catch(()=>{})}async#x(e,t,n){assertInFlightFollowUp(t);let r=this.#f,i=createAbortSignal(t.signal,e.abortController.signal),a=this.#r.projectResponses(t.inputResponses),o=await waitWithSignal(Promise.resolve(n?.(t)),i).then(e=>{let n=validateFollowUp(e??t);return n===t||(a=this.#r.replaceResponses(a,n)),n}).catch(e=>{throw a?.(),e});if(r!==this.#f)return;if(!this.#k(e))return a?.(),await this.#y(o);let s=this.#d.submit(o,this.#u.length,activeTurnForOptimisticFollowUp(this.#u));s!==void 0&&e.followUpSubmissionIds.add(s),this.#F();let c;c=(async()=>{try{let t=createAbortSignal(o.signal,e.abortController.signal);if(await waitWithSignal(e.response,t),!this.#k(e)||this.#g===void 0)throw Error(`The active eve turn ended before the follow-up could be sent.`);this.#C({headers:o.headers,streamReconnectPolicy:o.streamReconnectPolicy});let n=(await dispatchSessionTurn({session:this.#g,turn:{...o,signal:t}})).response;if(a=void 0,o.message===void 0)return;e.acceptedFollowUps+=1,this.#j(s,n)}catch(t){throw this.#k(e)&&(this.#d.fail(toError(t),s),a?.(),this.#F()),t}finally{e.followUpDispatches.delete(c)}})(),e.followUpDispatches.add(c),await c,await e.completion}async#S(e){let t={headers:e.headers,streamReconnectPolicy:e.streamReconnectPolicy};this.#p!==void 0&&(await waitWithSignal(this.#p.catch(e=>{if(this.#g!==void 0)throw e}),e.signal),e.signal?.throwIfAborted());let n=this.#g,r;try{let i=await dispatchSessionTurn({client:this.#e,session:n,turn:e,beforeSend:()=>{r=this.#C(t).subscribe(e.signal)}});return i.created&&(this.#w(i.session),r=this.#C(t).subscribe(e.signal)),{response:i.response,reader:r}}catch(e){throw r?.[Symbol.dispose](),e}}#C(e={}){if(this.#g===void 0)throw Error(`A session is required before opening its stream.`);let t=this.#f;return this.#i&&!this.#r.following&&this.#E(),this.#r.stream(this.#g,{...e,onEvent:e=>{t===this.#f&&this.#A(e)},onError:e=>{t===this.#f&&this.#s===void 0&&this.#T(e)}})}#w(e){this.#g=e,this.#i&&this.#n&&this.#E(),this.#c.onSessionChange?.(e.state),this.#F()}#T(e){this.#l=toError(e),this.#v=`error`,this.#c.onError?.(this.#l),this.#F()}#E(){this.#g&&this.#r.follow(this.#g,this.#u)}#D(){this.#f+=1,this.#m?.abort(),this.#m=void 0,this.#p=void 0}#O(e){if(this.#k(e)){e.resolveResponse(void 0),this.#s=void 0;try{this.#c.onSessionChange?.(this.#g?.state),this.#F(),this.#c.onFinish?.(this.#_)}finally{e.resolveCompletion()}}}#k(e){return this.#s===e}#A(e){let t=this.#v===`streaming`;if(!this.#r.observe(e,{onAccepted:()=>{this.#u=[...this.#u,e]},project:e=>{this.#M(this.#d.apply(e))},notify:!1}))return!1;this.#c.onEvent?.(e),this.#N(e);let{conversation:n}=this.#r,r=isSettledSessionTail(this.#u,n)&&n.activeTurnId===void 0;return this.#v!==`resuming`&&this.#l===void 0&&(`data`in e&&e.data!==void 0&&`turnId`in e.data&&(this.#v=`streaming`),this.#s===void 0&&r&&(this.#v=`ready`)),this.#c.onSessionChange?.(this.#g?.state),this.#v!==`resuming`&&this.#F(),this.#s===void 0&&t&&r&&this.#c.onFinish?.(this.#_),!0}#j(e,t){let n=getMessageResponseDeliveryId(t),r=this.#d.correlate(e,n,this.#u);this.#M(r)&&this.#F()}#M(e){return e!==void 0&&(this.#s!==void 0&&countFollowUpDeliveries(this.#s,e),!0)}#N(e){let t=toTerminalStreamFailureError(e);t!==void 0&&(this.#v=`error`,this.#d.failAll(t),this.#l===void 0&&(this.#l=t,this.#c.onError?.(t)))}#P(){return{data:this.#r.data,conversation:this.#r.conversation,error:this.#l,events:this.#u,session:this.#g?.state,status:this.#v}}#F(){this.#_=this.#P();for(let e of this.#o)e()}};function detachEveAgentStore(e){e[detachStore]()}function attachEveAgentStore(e){e[attachStore]()}export{EveAgentStore,attachEveAgentStore,detachEveAgentStore};

package/dist/src/client/index.d.ts

@@ -4,15 +4,19 @@ export { AgentInfoResponseError } from "#client/agent-info-error.js";
 export { HealthResponseError } from "#client/health-response-error.js";
 export { ClientError } from "#client/client-error.js";
 export { defaultMessageReducer } from "#client/message-reducer.js";
+export { conversationReducer } from "#client/conversation-reducer.js";
+export { openConversationInputs } from "#client/conversation-state.js";
+export type { AgentObservation, ConversationAgentSession, ConversationInput, ConversationState, ConversationTask, ConversationTaskCall, ConversationTurn, } from "#client/conversation-state.js";
 export { createDataUrlFilePart, createTextWithFileContent } from "#client/file-parts.js";
 export { MessageResponse } from "#client/message-response.js";
+export { ClientAgentSession } from "#client/agent-session.js";
 export { ClientSession } from "#client/session.js";
 export { ClientSessions, type CreatedClientSession, type CreatedIdleClientSession, } from "#client/sessions.js";
 export type { EveAgentStoreCallbacks, EveAgentStoreInit, EveAgentStoreSnapshot, EveAgentStoreStatus, PrepareSend, } from "#client/eve-agent-store.js";
 export type { AgentInfoEntry, AgentInfoChannelEntry, AgentInfoChannels, AgentInfoConnectionEntry, AgentInfoDynamicResolverEntry, AgentInfoHookEntry, AgentInfoInstructions, AgentInfoInstructionsEntry, AgentInfoResult, AgentInfoRemoteAgentEntry, AgentInfoSandboxEntry, AgentInfoScheduleEntry, AgentInfoSkillEntry, AgentInfoSource, AgentInfoSubagentEntry, AgentInfoToolEntry, AgentInfoTools, CancelSessionResult, ClearResult, CompactResult, ClientAuth, ClientOptions, ClientRedirectPolicy, CreateSessionOptions, HeadersValue, HealthResult, MessageResult, RespondTurnOptions, ResetResult, ResolvedStreamReconnectPolicy, SendTurnInput, SendTurnOptions, SessionSnapshot, ClientSessionState, StreamOptions, StreamReconnectPolicy, StreamReconnectRetryPolicy, TokenValue, } from "#client/types.js";
 export type { EveAgentReducer, EveAgentReducerEvent, ClientInputRespondedEvent, ClientMessageFailedEvent, ClientMessageSubmittedEvent, } from "#client/reducer.js";
 export type { EveAuthorizationChallenge, EveAuthorizationOutcome, EveAuthorizationPart, EveMessageData, EveDynamicToolPart, EveMessageInputRequest, EveMessage, EveMessageMetadata, EveMessagePart, EveMessageToolMetadata, } from "#client/message-reducer.js";
-export type { ActionPartialStreamEvent, ActionResultStreamEvent, ActionsRequestedStreamEvent, AssistantStepFinishReason, AuthorizationOutcome, CompactionCompletedStreamEvent, CompactionRequestedStreamEvent, AuthorizationCompletedStreamEvent, ConnectionAuthorizationOutcome, AuthorizationRequiredStreamEvent, HandleMessageStreamEvent, MessageStreamEventMeta, InputResolution, InputResolutionOutcome, InputResolvedStreamEvent, InputRequestedStreamEvent, MessageAppendedStreamEvent, MessageCompletedStreamEvent, MessageReceivedPart, MessageReceivedStreamEvent, ReasoningAppendedStreamEvent, ReasoningCompletedStreamEvent, ResultCompletedStreamEvent, RuntimeTraceContext, SessionCompletedStreamEvent, SessionFailedStreamEvent, SessionStartedStreamEvent, SessionWaitingStreamEvent, MessageStreamEvent, StepCompletedStreamEvent, StepFailedStreamEvent, StepStartedStreamEvent, SubagentCalledStreamEvent, SubagentChildEventStreamEvent, SubagentCompletedStreamEvent, SubagentStartedStreamEvent, TurnCancelledStreamEvent, TurnCompletedStreamEvent, TurnFailedStreamEvent, TurnStartedStreamEvent, TurnFailureStreamEvent, } from "#protocol/message.js";
+export type { ActionPartialStreamEvent, ActionResultStreamEvent, ActionsRequestedStreamEvent, AgentStartedStreamEvent, AssistantStepFinishReason, AuthorizationOutcome, CompactionCompletedStreamEvent, CompactionRequestedStreamEvent, AuthorizationCompletedStreamEvent, ConnectionAuthorizationOutcome, AuthorizationRequiredStreamEvent, HandleMessageStreamEvent, MessageStreamEventMeta, InputResolution, InputResolutionOutcome, InputResolvedStreamEvent, InputRequestedStreamEvent, MessageAppendedStreamEvent, MessageCompletedStreamEvent, MessageReceivedPart, MessageReceivedStreamEvent, ReasoningAppendedStreamEvent, ReasoningCompletedStreamEvent, ResultCompletedStreamEvent, RuntimeTraceContext, SessionCompletedStreamEvent, SessionFailedStreamEvent, SessionStartedStreamEvent, SessionWaitingStreamEvent, MessageStreamEvent, StepCompletedStreamEvent, StepFailedStreamEvent, StepStartedStreamEvent, TaskSettledStreamEvent, TaskStartedStreamEvent, TurnCancelledStreamEvent, TurnCompletedStreamEvent, TurnFailedStreamEvent, TurnStartedStreamEvent, TurnFailureStreamEvent, TurnWaitingOn, TurnWaitingStreamEvent, } from "#protocol/message.js";
 export { isCurrentTurnBoundaryEvent, isTurnFailureEvent } from "#protocol/message.js";
 export type { InputOption, InputRequest, InputRequestKind, InputResponse } from "#shared/input.js";
 export { isInputRequest, isInputResponse, parseInputResponse, parseInputResponses, } from "#shared/input.js";

package/dist/src/client/index.js

@@ -1 +1 @@
-import{isInputRequest,isInputResponse,parseInputResponse,parseInputResponses}from"#shared/input.js";import{isCurrentTurnBoundaryEvent,isTurnFailureEvent}from"#protocol/message.js";import{AgentInfoResponseError}from"#client/agent-info-error.js";import{HealthResponseError}from"#client/health-response-error.js";import{ClientError}from"#client/client-error.js";import{ClientSessions}from"#client/sessions.js";import{Client}from"#client/client.js";import{MessageResponse}from"#client/message-response.js";import{EveAgentStore}from"#client/eve-agent-store.js";import{defaultMessageReducer}from"#client/message-reducer.js";import{createDataUrlFilePart,createTextWithFileContent}from"#client/file-parts.js";import{ClientSession}from"#client/session.js";import{resolveTextToResponse,resolveTextToResponses}from"#channel/resolve-text.js";export{AgentInfoResponseError,Client,ClientError,ClientSession,ClientSessions,EveAgentStore,HealthResponseError,MessageResponse,createDataUrlFilePart,createTextWithFileContent,defaultMessageReducer,isCurrentTurnBoundaryEvent,isInputRequest,isInputResponse,isTurnFailureEvent,parseInputResponse,parseInputResponses,resolveTextToResponse,resolveTextToResponses};
+import{isInputRequest,isInputResponse,parseInputResponse,parseInputResponses}from"#shared/input.js";import{openConversationInputs}from"#client/conversation-state.js";import{EveAgentStore}from"#client/eve-agent-store.js";import{isCurrentTurnBoundaryEvent,isTurnFailureEvent}from"#protocol/message.js";import{AgentInfoResponseError}from"#client/agent-info-error.js";import{HealthResponseError}from"#client/health-response-error.js";import{ClientError}from"#client/client-error.js";import{ClientSessions}from"#client/sessions.js";import{conversationReducer}from"#client/conversation-reducer.js";import{defaultMessageReducer}from"#client/message-reducer.js";import{Client}from"#client/client.js";import{MessageResponse}from"#client/message-response.js";import{createDataUrlFilePart,createTextWithFileContent}from"#client/file-parts.js";import{ClientAgentSession}from"#client/agent-session.js";import{ClientSession}from"#client/session.js";import{resolveTextToResponse,resolveTextToResponses}from"#channel/resolve-text.js";export{AgentInfoResponseError,Client,ClientAgentSession,ClientError,ClientSession,ClientSessions,EveAgentStore,HealthResponseError,MessageResponse,conversationReducer,createDataUrlFilePart,createTextWithFileContent,defaultMessageReducer,isCurrentTurnBoundaryEvent,isInputRequest,isInputResponse,isTurnFailureEvent,openConversationInputs,parseInputResponse,parseInputResponses,resolveTextToResponse,resolveTextToResponses};