eve 0.83.2 → 0.84.0

package/dist/src/react/use-eve-agent.d.ts

@@ -1,60 +1,71 @@
-import { type EveAgentStoreCallbacks, type EveAgentStoreSnapshot, type EveAgentStoreStatus, type PrepareSend } from "#client/eve-agent-store.js";
-import type { EveAgentReducer } from "#client/reducer.js";
+import type { Delivery } from "#shared/delivery.js";
+import type { SessionStreamEvent } from "#protocol/session-event.js";
+import { type SessionStoreCallbacks, type SessionStoreInit, type SessionStoreSnapshot, type SessionStoreStatus, type PrepareSend } from "#client/session-store.js";
 import type { ClientSession } from "#client/session.js";
-import type { ConversationState } from "#client/conversation-state.js";
-import type { MessageStreamEvent } from "#protocol/message.js";
-import type { UserContent } from "ai";
-import type { CancelSessionResult, ClientAuth, HeadersValue, RespondTurnOptions, SendTurnOptions, ClientSessionState } from "#client/types.js";
+import type { MessageContent } from "#shared/message-content.js";
+import type { ClientAuth, HeadersValue, RespondTurnOptions, SendTurnOptions, ClientSessionState } from "#client/types.js";
 export type { PrepareSend };
 /**
- * Lifecycle status of an eve agent session.
+ * Outstanding work this binding has observed or still owes. Failures are reported separately in
+ * `error`.
  *
- * - `"ready"`: idle, accepting a new turn.
- * - `"resuming"`: checking an attached session for events; submission is disabled.
- * - `"submitted"`: a turn was sent, no stream events received yet.
- * - `"streaming"`: stream events are arriving for the active turn.
- * - `"error"`: the last turn ended in a terminal failure (see `snapshot.error`).
+ * - `"idle"`: no command, answer, or followed receipt is pending, and the last observed view is
+ *   idle. A turn waiting only on a person can still be open; read `activeTurn(view)`.
+ * - `"resuming"`: catching up on an attached session; submission is disabled.
+ * - `"busy"`: a send, answer, or control command is pending, a followed receipt has not settled,
+ *   or the session has running or queued work.
+ *
+ * After `followWhile` closes the stream, `status` reflects the last observed view, not the
+ * current server state.
  */
-export type UseEveAgentStatus = EveAgentStoreStatus;
+export type UseEveAgentStatus = SessionStoreStatus;
 /**
- * Snapshot of an eve agent session: `conversation` (canonical state), `data`
- * (the selected view), `events` (the authoritative server stream), `session`
- * (resumable cursor), `status`, and `error`.
+ * Snapshot of an eve agent session: the conversation (`messages`, `agents`, `view`),
+ * `events` (the authoritative server stream), `session` (resumable cursor),
+ * `status`, and `error`.
  */
-export type UseEveAgentSnapshot<TData> = EveAgentStoreSnapshot<TData>;
+export type UseEveAgentSnapshot = SessionStoreSnapshot;
 /**
  * Snapshot plus commands returned by `useEveAgent`.
  */
-export interface UseEveAgentHelpers<TData> extends UseEveAgentSnapshot<TData> {
-    /** Requests durable cancellation of the active turn while continuing to receive its events. */
-    readonly cancel: () => Promise<CancelSessionResult>;
-    /** Replays the attached durable session and follows its in-flight turn, if any. */
+export interface UseEveAgentReturn extends UseEveAgentSnapshot {
+    /**
+     * Requests durable cancellation of the active turn while continuing to receive its events.
+     * Offer it while `activeTurn(view)` returns a turn, including one waiting on a person.
+     */
+    readonly cancel: () => Promise<Delivery>;
+    /** Follow a same-session delivery receipt from this or another store until settlement. */
+    readonly follow: (receipt: Pick<Delivery, "sessionId" | "deliveryId">) => void;
+    /** Resolves at the durable tail; subsequent following obeys `followWhile`. */
     readonly resume: () => Promise<void>;
     /** Creates the session without starting its first turn. */
     readonly prewarm: () => Promise<void>;
     /** Resets the session: detaches any local stream and clears events and projected data. */
-    readonly reset: () => void;
-    /** Sends a message. While a turn is active, pass `turnPolicy: "steer"` to replace it. */
-    readonly send: <TOutput = unknown>(message: string | UserContent, options?: SendTurnOptions<TOutput>) => Promise<void>;
-    /** Answers pending HITL input requests. Rejects if a turn is already in flight. */
-    readonly respond: <TOutput = unknown>(inputResponses: Parameters<ClientSession["respond"]>[0], options?: RespondTurnOptions<TOutput>) => Promise<void>;
+    readonly newSession: () => void;
+    readonly reset: () => Promise<Delivery>;
+    readonly clear: () => Promise<Delivery>;
+    readonly compact: () => Promise<Delivery>;
+    /** Resolves on acceptance. Use `turnPolicy` to steer or queue during a running turn. */
+    readonly send: <TOutput = unknown>(message: MessageContent, options?: SendTurnOptions<TOutput>) => Promise<Delivery<TOutput>>;
+    /** Submits answers to open interactions and resolves on acceptance, not execution. */
+    readonly respond: <TOutput = unknown>(answers: Parameters<ClientSession["respond"]>[0], options?: RespondTurnOptions<TOutput>) => Promise<Delivery<TOutput>>;
 }
 /**
  * Configuration for creating or binding a React eve agent session.
  *
  * Session configuration is read when the hook creates its internal store;
- * remount the component to point at a different host, reducer, or session.
+ * remount the component to point at a different base URL or session.
  * Lifecycle callbacks update on every render.
  *
  * For credentials or headers that must change without remounting, pass function
  * values to `auth` or `headers`; the client resolves those before each request.
  */
-export interface UseEveAgentOptions<TData> extends EveAgentStoreCallbacks<TData> {
+export interface UseEveAgentOptions extends SessionStoreCallbacks {
     /**
      * Named agent mounted by a framework integration such as `withEve({ agents })`.
      *
      * `agent: "support"` targets same-origin routes under
-     * `/eve/support/v1/...`. Do not combine with `host`.
+     * `/eve/support/v1/...`. Do not combine with `baseUrl`.
      */
     readonly agent?: string;
     readonly auth?: ClientAuth;
@@ -68,32 +79,29 @@ export interface UseEveAgentOptions<TData> extends EveAgentStoreCallbacks<TData>
      *
      * @default ""
      */
-    readonly host?: string;
+    readonly baseUrl?: string;
     /** Ordered prefix of the session stream used to rehydrate projected state. */
-    readonly initialEvents?: readonly MessageStreamEvent[];
+    readonly initialEvents?: readonly SessionStreamEvent[];
     readonly initialSession?: ClientSessionState;
     /**
      * Project submitted user messages before eve confirms them with a
-     * `message.received` stream event.
+     * `delivery.consumed` fact.
      *
-     * Optimistic events are reducer-facing projection events only. They are not
-     * exposed through `events`, which remains the authoritative eve stream.
+     * Such a message shows in `messages` only; `events` remains the
+     * authoritative eve stream.
      *
      * @default true
      */
     readonly optimistic?: boolean;
-    /** Follow each subagent call's session into `conversation.agents` while mounted. @default false */
-    readonly followSubagents?: boolean;
-    /**
-     * Keep the session stream open between turns to show events that arrive from schedules,
-     * channels, or other clients. Set to false to close it once the session is idle and reopen it
-     * on the next send, answer, or resume. @default true
-     */
-    readonly followIdle?: boolean;
+    /** Recursively observe recorded children, or select relationships with a predicate, within store safety limits. @default false */
+    readonly followAgents?: SessionStoreInit["followAgents"];
+    /** Keep following while the committed view matches; local obligations always keep the stream open. @default () => true */
+    readonly followWhile?: (view: SessionStoreSnapshot["view"]) => boolean;
     /**
-     * Create a session or prepare its existing idle owner when true. React observes this value across renders;
-     * changing it from false to true prepares the current session, and reset checks
-     * the latest rendered value before preparing the next session.
+     * Create a session or prepare its existing idle owner when true. React observes
+     * this value across renders; changing it from false to true prepares the current
+     * session, and `newSession()` checks the latest rendered value before preparing
+     * the next session.
      *
      * Changing the value to false does not discard an existing session or abort
      * session creation already in flight.
@@ -101,7 +109,6 @@ export interface UseEveAgentOptions<TData> extends EveAgentStoreCallbacks<TData>
      * @default false
      */
     readonly prewarm?: boolean;
-    readonly reducer?: EveAgentReducer<TData>;
     /**
      * Replay the attached durable session after mount and follow its in-flight
      * turn, if any. Requires `initialSession` or `session`.
@@ -111,7 +118,18 @@ export interface UseEveAgentOptions<TData> extends EveAgentStoreCallbacks<TData>
     readonly resume?: boolean;
     readonly session?: ClientSession;
 }
-export declare function useEveAgent(options?: UseEveAgentOptions<ConversationState>): UseEveAgentHelpers<ConversationState>;
-export declare function useEveAgent<TData>(options: UseEveAgentOptions<TData> & {
-    readonly reducer: EveAgentReducer<TData>;
-}): UseEveAgentHelpers<TData>;
+/**
+ * React hook that drives an eve session and projects its event stream into UI data.
+ *
+ * Returns the current snapshot (the conversation's `messages`, `agents`, and `view`, plus
+ * `events`, `session`, `status`, and `error`) and the commands `prewarm`, `send`, `respond`,
+ * `resume`, `cancel`, `newSession`, and `reset`. Read lifecycle from `view` with selectors
+ * from `eve/events`.
+ *
+ * Session-shaping options (`baseUrl`, `session`, `initialEvents`,
+ * `initialSession`, `auth`, `headers`, `optimistic`, `resume`) are read once
+ * when the store is created; remount to change them. `prewarm` and lifecycle
+ * callbacks (`onError`, `onEvent`, `onFinish`, `onSessionChange`, `prepareSend`)
+ * and `followWhile` refresh on every render.
+ */
+export declare function useEveAgent(options?: UseEveAgentOptions): UseEveAgentReturn;

package/dist/src/react/use-eve-agent.js

@@ -1 +1 @@
-import{EveAgentStore,attachEveAgentStore,detachEveAgentStore}from"#client/eve-agent-store.js";import{conversationReducer}from"#client/conversation-reducer.js";import{useCallback,useEffect,useMemo,useRef,useState,useSyncExternalStore}from"react";import{resolveEveAgentHost}from"#client/agent-host.js";function useEveAgent(e={}){let t=useRef(void 0),n=useRef(!1),r=useRef(e.resume??!1),[i,a]=useState(r.current),[o,s]=useState(0),c=e.prewarm??!1;if(!t.current){if(r.current&&e.initialSession===void 0&&e.session===void 0)throw Error(`useEveAgent({ resume: true }) requires initialSession or session.`);let n=e.reducer??conversationReducer;t.current=new EveAgentStore({auth:e.auth,headers:e.headers,host:resolveEveAgentHost({agent:e.agent,host:e.host}),initialEvents:e.initialEvents,initialSession:e.initialSession,optimistic:e.optimistic,followSubagents:e.followSubagents,followIdle:e.followIdle,reducer:n,session:e.session})}let l=t.current;l.setCallbacks({onError:e.onError,onEvent:e.onEvent,onFinish:e.onFinish,onSessionChange:e.onSessionChange,prepareSend:e.prepareSend});let u=useCallback(e=>l.subscribe(e),[l]),d=useSyncExternalStore(u,()=>l.snapshot,()=>l.snapshot);useEffect(()=>{n.current=!0;let e=setTimeout(()=>attachEveAgentStore(l),0);return()=>{n.current=!1,clearTimeout(e),queueMicrotask(()=>{n.current||detachEveAgentStore(l)})}},[l]),useEffect(()=>{if(!c)return;let e=setTimeout(()=>void l.prewarm().catch(()=>{}),0);return()=>clearTimeout(e)},[o,c,l]),useEffect(()=>{if(!r.current)return;let e=!0,finish=()=>{e&&a(!1)},t=setTimeout(()=>void l.resume().then(finish,finish),0);return()=>{e=!1,clearTimeout(t)}},[l]);let f=useCallback(()=>l.cancel(),[l]),p=useCallback(()=>{l.reset(),s(e=>e+1)},[l]),m=useCallback(()=>l.prewarm(),[l]),h=useCallback(()=>l.resume(),[l]),g=useCallback((e,t)=>l.send({...t,message:e}),[l]),_=useCallback((e,t)=>l.send({...t,inputResponses:e}),[l]),v=i&&d.status===`ready`?{...d,status:`resuming`}:d;return useMemo(()=>({...v,cancel:f,prewarm:m,reset:p,respond:_,resume:h,send:g}),[f,m,p,_,h,g,v])}export{useEveAgent};
+import{SessionStore,attachSessionStore,detachSessionStore}from"#client/session-store.js";import{useCallback,useEffect,useMemo,useRef,useState,useSyncExternalStore}from"react";import{resolveEveAgentBaseUrl}from"#client/agent-base-url.js";function useEveAgent(e={}){let t=useRef(void 0),n=useRef(e.followWhile);n.current=e.followWhile;let r=useRef(!1),i=useRef(e.resume??!1),[a,o]=useState(i.current),[s,c]=useState(0),l=e.prewarm??!1;if(!t.current){if(i.current&&e.initialSession===void 0&&e.session===void 0)throw Error(`useEveAgent({ resume: true }) requires initialSession or session.`);t.current=new SessionStore({auth:e.auth,headers:e.headers,baseUrl:resolveEveAgentBaseUrl({agent:e.agent,baseUrl:e.baseUrl}),initialEvents:e.initialEvents,initialSession:e.initialSession,optimistic:e.optimistic,followAgents:e.followAgents,followWhile:e=>n.current?.(e)??!0,session:e.session})}let u=t.current;u.setCallbacks({onError:e.onError,onEvent:e.onEvent,onFinish:e.onFinish,onSessionChange:e.onSessionChange,prepareSend:e.prepareSend});let d=useCallback(e=>u.subscribe(e),[u]),f=useSyncExternalStore(d,()=>u.snapshot,()=>u.snapshot);useEffect(()=>{r.current=!0;let e=setTimeout(()=>attachSessionStore(u),0);return()=>{r.current=!1,clearTimeout(e),queueMicrotask(()=>{r.current||detachSessionStore(u)})}},[u]),useEffect(()=>{if(!l)return;let e=setTimeout(()=>void u.prewarm().catch(()=>{}),0);return()=>clearTimeout(e)},[s,l,u]),useEffect(()=>{if(!i.current)return;let e=!0,finish=()=>{e&&o(!1)},t=setTimeout(()=>void u.resume().then(finish,finish),0);return()=>{e=!1,clearTimeout(t)}},[u]);let p=useCallback(()=>u.cancel(),[u]),m=useCallback(()=>u.reset(),[u]),h=useCallback(()=>u.clear(),[u]),g=useCallback(()=>u.compact(),[u]),_=useCallback(()=>{u.newSession(),c(e=>e+1)},[u]),v=useCallback(()=>u.prewarm(),[u]),y=useCallback(()=>u.resume(),[u]),b=useCallback(e=>u.follow(e),[u]),x=useCallback((e,t)=>u.send({...t,message:e}),[u]),S=useCallback((e,t)=>u.send({...t,answers:e}),[u]),C=a&&f.status===`idle`?{...f,status:`resuming`}:f;return useMemo(()=>({...C,cancel:p,clear:h,compact:g,newSession:_,prewarm:v,reset:m,respond:S,resume:y,follow:b,send:x}),[p,h,g,b,_,v,m,S,y,x,C])}export{useEveAgent};

package/dist/src/reactions/bundle.d.ts

@@ -0,0 +1,4 @@
+import type { ContextReader } from "#context/key.js";
+import { type BundleReactions } from "./reaction.js";
+/** The reactions the session's agent declares, in run order. */
+export declare function bundleReactions(ctx: Pick<ContextReader, "get" | "has">): Promise<BundleReactions>;

package/dist/src/reactions/bundle.js

@@ -0,0 +1 @@
+import{REACTION_ORDER}from"./reaction.js";import{toolReaction}from"./kinds/tool.js";import{connectionReaction,installDynamicConnections}from"./kinds/connection.js";import{hookReaction}from"./kinds/hook.js";import{instructionsReaction}from"./kinds/instructions.js";import{loadModelReaction}from"./kinds/model.js";import{memoryReactions}from"./kinds/memory.js";import{skillReaction,syncDynamicSkillFiles}from"./kinds/skill.js";import{subagentReaction}from"./kinds/subagent.js";import{AgentSessionRuntimeOverridesKey,DynamicSubagentAgentConfigKey}from"#context/keys.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";const cache=new WeakMap,EMPTY={effects:{},reactions:[]};async function bundleReactions(e){let t=e.get(BundleKey);if(t===void 0)return EMPTY;let n=cache.get(t);n===void 0&&(n=buildReactions(t),cache.set(t,n),n.catch(()=>cache.delete(t)));let r=await n;return!e.has(DynamicSubagentAgentConfigKey)&&!e.has(AgentSessionRuntimeOverridesKey)?r:{...r,reactions:r.reactions.filter(e=>e.kind!==`model`)}}async function buildReactions(e){let t=e.resolvedAgent,n=await loadModelReaction(e),r=[...t.hooks.map(hookReaction),...t.memories.flatMap(memoryReactions),...n===void 0?[]:[n],...(t.dynamicConnectionResolvers??[]).map(connectionReaction),...e.subagentRegistry.dynamicResolvers.map(subagentReaction),...t.dynamicToolResolvers.map(toolReaction),...t.dynamicSkillResolvers.map(skillReaction),...t.dynamicInstructionsResolvers.map(instructionsReaction)];return r.sort((e,t)=>REACTION_ORDER.indexOf(e.kind)-REACTION_ORDER.indexOf(t.kind)),{effects:{...(t.dynamicConnectionResolvers??[]).length===0?{}:{connection:installDynamicConnections},...t.dynamicSkillResolvers.length!==0&&{skill:syncDynamicSkillFiles}},reactions:r}}export{bundleReactions};

package/dist/src/reactions/frame.d.ts

@@ -0,0 +1,13 @@
+import type { ContextReader } from "#context/key.js";
+import type { SessionFrame } from "#dynamic/definition.js";
+import type { SessionView } from "#protocol/session-projection/tables.js";
+/** The channel the session's latest delivery came through. */
+export declare function channelOf(ctx: ContextReader): SessionFrame["channel"];
+/**
+ * The session as of its latest commit, or as of the commit `at` the given view: what every
+ * dynamic value and hook handler reads.
+ */
+export declare function sessionFrameOf(ctx: ContextReader, input?: {
+    readonly view?: SessionView;
+    readonly at?: string;
+}): SessionFrame;

package/dist/src/reactions/frame.js

@@ -0,0 +1 @@
+import{readReactionsState,sessionIdOf}from"./state.js";import{latestTurn}from"./turn.js";import{normalizeInstrumentationChannelKind}from"#shared/instrumentation-channel-kind.js";import{ConversationContextKey}from"#shared/conversation-context.js";import{getAdapterKind}from"#channel/adapter.js";import{snapshotOf}from"#protocol/session-projection/session-view.js";import{AuthKey,ChannelInstrumentationKey,ContinuationTokenKey,InitiatorAuthKey,ParentSessionKey,SessionPredecessorKey}from"#context/keys.js";import{readSessionSchedule}from"#context/session-schedule.js";import{ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{currentView}from"#harness/session-machine/current.js";function channelOf(e){let t=e.get(ChannelKey),n=e.get(ChannelInstrumentationKey);return{continuationToken:e.get(ContinuationTokenKey),kind:normalizeInstrumentationChannelKind(n?.kind??(t===void 0?void 0:getAdapterKind(t))),metadata:n?.metadata??{}}}function sessionFrameOf(e,t={}){let n=e.get(ConversationContextKey),r=e.get(ParentSessionKey),i=t.view??currentView(e),a=t.at??readReactionsState(e).at??i.session.startedAt;return{channel:channelOf(e),...n!==void 0&&{conversation:n},now:new Date(a??0),session:{auth:{current:e.get(AuthKey)??null,initiator:e.get(InitiatorAuthKey)??null},id:sessionIdOf(e),...r!==void 0&&{parent:r},predecessor:e.get(SessionPredecessorKey),schedule:readSessionSchedule(e)},turn:latestTurn(i),view:snapshotOf(i)}}export{channelOf,sessionFrameOf};

package/dist/src/reactions/intents.d.ts

@@ -0,0 +1,22 @@
+import type { ContextContainer } from "#context/container.js";
+import type { Reaction } from "./reaction.js";
+import { type PendingIntent } from "./state.js";
+/** A command a hook asked for, before it's queued. */
+export interface Command {
+    readonly type: "cancel";
+    readonly reason?: string;
+}
+/**
+ * Adds cancellations to the session's queue. Requests between turns are dropped.
+ */
+export declare function queueCommands(ctx: ContextContainer, reactionId: string, occurrence: string, commands: readonly Command[]): void;
+/** Removes and returns the waiting intents that match, because the session acted on them. */
+export declare function takeIntents(ctx: ContextContainer, matches: (intent: PendingIntent) => boolean): readonly PendingIntent[];
+/**
+ * A hook, or an effect eve runs after a commit, failed. During a turn, the turn fails at its next
+ * boundary: before its next model call, or as it would settle. Between turns, there's no turn to
+ * fail, and the failure is logged.
+ */
+export declare function reportReactionFailure(ctx: ContextContainer, reaction: Pick<Reaction, "id" | "kind" | "label">, error: unknown, occurrence?: string): void;
+/** Takes the failure a hook reported for the running turn, if any. */
+export declare function takeTurnFailure(ctx: ContextContainer | undefined): string | undefined;

package/dist/src/reactions/intents.js

@@ -0,0 +1 @@
+import{readReactionsState,writeReactionsState}from"./state.js";import{createLogger}from"#internal/logging.js";import{toErrorMessage}from"#shared/errors.js";import{currentProjection}from"#harness/session-machine/current.js";import{activeTurnIdOf}from"#protocol/session-projection.js";const log=createLogger(`hooks`);function queueCommands(e,t,n,r){if(r.length===0)return;let i=readReactionsState(e),a=[...i.intents??[]],o=activeTurnIdOf(currentProjection(e)),s=!1;for(let e of r)o!==void 0&&i.cancelledTurnId!==o&&(a.some(e=>e.type===`cancel`&&e.turnId===o)||(a.push({occurrence:n,reactionId:t,type:e.type,...e.reason!==void 0&&{reason:e.reason},turnId:o}),s=!0));s&&writeReactionsState(e,{...i,intents:a})}function takeIntents(e,t){let n=readReactionsState(e),r=(n.intents??[]).filter(t);if(r.length===0)return r;let i=(n.intents??[]).filter(e=>!t(e));return writeReactionsState(e,{...n,intents:i}),r}function reportReactionFailure(e,t,n,r){let i=activeTurnIdOf(currentProjection(e)),a=toErrorMessage(n),o=`${t.kind===`memory`?`Memory`:`Hook`} "${t.label}"`;if(log.error(`${o} failed.`,{error:a,occurrence:r,turnId:i}),i===void 0)return;let s=readReactionsState(e),c=s.intents??[];c.some(e=>e.type===`fail`&&e.turnId===i)||writeReactionsState(e,{...s,intents:[...c,{occurrence:r??`fail:${i}`,reactionId:t.id,reason:`${o} failed: ${a}`,turnId:i,type:`fail`}]})}function takeTurnFailure(e){if(e===void 0)return;let t=activeTurnIdOf(currentProjection(e));if(t===void 0)return;let[n]=takeIntents(e,e=>e.type===`fail`&&e.turnId===t);return n?.reason}export{queueCommands,reportReactionFailure,takeIntents,takeTurnFailure};

package/dist/src/reactions/kinds/connection.d.ts

@@ -0,0 +1,18 @@
+import type { ContextContainer } from "#context/container.js";
+import type { ContextReader } from "#context/key.js";
+import type { ResolvedDynamicConnectionResolver } from "#runtime/types.js";
+import { type ValueReaction } from "../reaction.js";
+/**
+ * A `defineDynamic()` in `agent/connections/`: one connection named after the file, or a map.
+ * Rebuild callbacks even when the target is unchanged: the current policy can have changed.
+ */
+export declare function connectionReaction(resolver: ResolvedDynamicConnectionResolver): ValueReaction;
+/** Installs the slots' connections in the step's registry, which starts with the static ones. */
+export declare function installDynamicConnections(ctx: ContextContainer): Promise<void>;
+/**
+ * Every connection name the session has: the registry's, and those dynamic connections this
+ * evaluation already returned, which the registry installs only after every value has run.
+ */
+export declare function sessionConnectionNames(ctx: Pick<ContextReader, "get">): readonly string[];
+/** The version of each dynamic connection, by name: what it reaches, and its memo results. */
+export declare function dynamicConnectionVersions(ctx: Pick<ContextReader, "get"> | undefined): ReadonlyMap<string, string>;

package/dist/src/reactions/kinds/connection.js

@@ -0,0 +1 @@
+import{authoredEvaluate}from"../reaction.js";import{entryVersions,slotsOf}from"../state.js";import{dynamicToolNames}from"./tool.js";import{assertNotConnectionOwned}from"#connections/ownership.js";import{eveNamespaceReservation}from"#protocol/runtime-tools.js";import{readStampedConnectionProtocol}from"#public/definitions/connections/protocol.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{ConnectionRegistryKey}from"#context/providers/connection-key.js";import{ConnectionRegistryImpl}from"#runtime/connections/registry.js";import{CONNECTION_SLUG_PATTERN}from"#discover/grammar.js";import{resolveDynamicConnectionValue}from"#runtime/resolve-connection.js";function connectionReaction(e){return{contribute:(t,{ctx:n})=>{let r=namedConnections(e,t).map(({name:t,value:n})=>resolveDynamicConnectionValue(n,{connectionName:t,exportName:e.exportName,logicalPath:e.logicalPath,sourceId:e.sourceId,sourceKind:`module`}));return assertOwnsNoEntries(n,r,e),r.length===0?{value:null}:{live:r,value:r.map(target)}},id:`connection:${e.extensionNamespace??``}:${e.slug}`,kind:`connection`,evaluate:authoredEvaluate(e.evaluate,{framework:e.framework}),label:e.logicalPath}}function target(e){let t=e.authorization,n=typeof t==`object`&&t?t.principalType:void 0;return{name:e.connectionName,protocol:e.protocol,url:e.url,...e.instanceId!==void 0&&{instanceId:e.instanceId},...n!==void 0&&{principalType:n}}}async function installDynamicConnections(e){let t=e.get(ConnectionRegistryKey);t instanceof ConnectionRegistryImpl&&await t.replaceDynamicConnections(new Map(slotsOf(e,`connection`).map(({id:e,live:t})=>[e,t??[]])))}function sessionConnectionNames(e){return[...new Set([...e.get(ConnectionRegistryKey)?.getConnectionNames()??[],...dynamicConnectionVersions(e).keys()])]}function dynamicConnectionVersions(e){let t=new Map;for(let{id:n,slot:r}of slotsOf(e,`connection`)){let i=entryVersions(e,n);for(let e of Array.isArray(r.value)?r.value:[]){let n=e?.name;typeof n==`string`&&!t.has(n)&&t.set(n,i(e))}}return t}function namedConnections(e,t){if(t==null)return[];if(readStampedConnectionProtocol(t)!==void 0)return[{name:e.slug,value:t}];if(typeof t!=`object`||Array.isArray(t))throw Error(`The defineDynamic() in "${e.logicalPath}" must return a connection definition, a map of connection definitions, or null.`);let n=e.extensionNamespace===void 0?``:`${e.extensionNamespace}__`;return Object.entries(t).map(([t,r])=>{if(!CONNECTION_SLUG_PATTERN.test(t))throw Error(`The defineDynamic() in "${e.logicalPath}" returned illegal connection name "${t}". Expected lowercase ASCII letters, digits, and dashes only, starting with a letter, up to 64 characters.`);if(readStampedConnectionProtocol(r)===void 0)throw Error(`The defineDynamic() in "${e.logicalPath}" returned "${t}" without defineMcpClientConnection() or defineOpenAPIConnection().`);return{name:`${n}${t}`,value:r}})}function assertOwnsNoEntries(e,t,n){for(let{connectionName:e}of t){let t=eveNamespaceReservation(e);if(t!==void 0)throw Error(`The defineDynamic() in "${n.logicalPath}" returned the reserved connection name "${e}". ${t}; rename the connection.`)}let r=e.get(BundleKey),i=[...r?.toolRegistry.toolsByName.keys()??[],...r?.subagentRegistry.subagentsByName.keys()??[],...r?.subagentRegistry.dynamicResolvers.map(e=>e.name)??[],...dynamicToolNames(e)],a=t.map(e=>e.connectionName);for(let e of i)assertNotConnectionOwned({connectionNames:a,name:e,remedy:`Rename it, or the dynamic connection that "${n.logicalPath}" returned.`,subject:`Tool or subagent`})}export{connectionReaction,dynamicConnectionVersions,installDynamicConnections,sessionConnectionNames};

package/dist/src/reactions/kinds/hook.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedHookDefinition } from "#runtime/types.js";
+import type { CommitReaction } from "../reaction.js";
+/**
+ * An authored hook as a reaction: its handlers run after every commit, once for each fact of
+ * their type, typed handler first, then `*`. Its occurrence identifies the fact for external
+ * services that support idempotency.
+ */
+export declare function hookReaction(hook: ResolvedHookDefinition): CommitReaction;

package/dist/src/reactions/kinds/hook.js

@@ -0,0 +1 @@
+import{discardedByDeployment,keepMemos,mergeMemos,readReactionsState}from"../state.js";import{queueCommands,reportReactionFailure}from"../intents.js";import{sessionFrameOf}from"../frame.js";import{openMemos}from"../records.js";import{buildCallbackContext}from"#context/build-callback-context.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{currentProjection}from"#harness/session-machine/current.js";import{activeTurnIdOf}from"#protocol/session-projection.js";function hookReaction(e){let t={id:`hook:${e.slug}`,kind:`hook`,label:e.logicalPath};return{...t,onCommit:async n=>{for(let{event:r,position:i,progress:a,view:o}of n.written){let{meta:s,...c}=r;for(let r of a?[c.type]:[c.type,`*`]){let a=e.events[r];a!==void 0&&await runHandler({at:s?.at,event:c,handler:a,input:n,key:r,occurrence:`${i.line}.${i.index}`,position:i,reaction:t,view:o})}}},timing:`commit`}}async function runHandler(e){let{ctx:t,abortSignal:n}=e.input,{id:r,label:i}=e.reaction,a=buildCallbackContext(),o=sessionFrameOf(t,{at:e.at,view:e.view}),s=a.session.id,c=`${s}:${r}:${e.occurrence}:${e.key}`,l=`${r}#${e.key}`,u=!1,d=openMemos({abortSignal:n,afterDeployment:discardedByDeployment(t,l),kept:readReactionsState(t).memos?.[l],label:i,scope:l,sessionId:s}),f=[],command=e=>t=>{if(u)throw Error(`Hook "${i}" called ctx.${e}() after its handler settled. Await the work that calls it before the handler returns.`);f.push(t===void 0?{type:e}:{reason:t,type:e})},p={...a,...o,agent:agentOf(t),cancel:command(`cancel`),memo:d.memo,occurrence:{abortSignal:n,idempotencyKey:c},position:e.position,session:{...a.session,...o.session}};try{await e.handler(e.event,p),keepMemos(t,l,d.used()),u=!0;let n=e.event.type===`delivery.admitted`&&activeTurnIdOf(currentProjection(t))===void 0?e.input.cancelBeforeTurn:void 0;if(n===void 0)queueCommands(t,r,c,f);else for(let{reason:e}of f)n({hook:i,...e!==void 0&&{reason:e}})}catch(n){mergeMemos(t,l,d.used()),reportReactionFailure(t,e.reaction,n,c)}finally{u=!0,d.close()}}function agentOf(e){let t=e.require(BundleKey);return{name:t.turnAgent.id,nodeId:t.nodeId}}export{hookReaction};

package/dist/src/reactions/kinds/instructions.d.ts

@@ -0,0 +1,21 @@
+import type { SystemModelMessage } from "ai";
+import type { AlsContext } from "#context/container.js";
+import type { ContextReader } from "#context/key.js";
+import { type UserModelMessage } from "#harness/messages.js";
+import type { ResolvedDynamicInstructionsResolver } from "#runtime/types.js";
+import { type ValueReaction } from "../reaction.js";
+/**
+ * A `defineDynamic()` in `agent/instructions/`. A system instruction is part of every model call
+ * while its definition returns it; a user instruction joins the conversation when its content
+ * changes, and stays there.
+ */
+export declare function instructionsReaction(resolver: ResolvedDynamicInstructionsResolver): ValueReaction;
+/** The system instructions the session's slots hold, in run order. */
+export declare function dynamicInstructionMessages(ctx: Pick<ContextReader, "get"> | undefined): SystemModelMessage[];
+/**
+ * User instructions whose content differs from what their definition last added; records each
+ * one's digest. A definition that returns `null`, or a system instruction, resets it, so the same
+ * content returned later joins again. The digests outlive deployments: new code doesn't add the
+ * same text again.
+ */
+export declare function takeUserInstructionMessages(ctx: AlsContext): UserModelMessage[];

package/dist/src/reactions/kinds/instructions.js

@@ -0,0 +1 @@
+import{authoredEvaluate}from"../reaction.js";import{readReactionsState,slotsOf,writeReactionsState}from"../state.js";import{normalizeInstructionsDefinition}from"#internal/authored-definition/core.js";import{createFrameworkUserMessage}from"#harness/messages.js";import{isBrandedInstructionsEntry}from"#shared/instructions-definition.js";function instructionsReaction(e){return{contribute:t=>{if(t==null)return{value:null};if(!isBrandedInstructionsEntry(t))throw Error(`The dynamic instructions "${e.slug}" returned an unbranded value — wrap with defineInstructions().`);let n=normalizeInstructionsDefinition(t,`Expected dynamic instructions to match the public eve shape.`),r=n.content.trim();return{value:r.length===0?null:{content:r,role:n.role??`system`}}},id:`instructions:${e.slug}`,kind:`instructions`,evaluate:authoredEvaluate(e.evaluate,{framework:e.framework}),label:e.logicalPath}}function dynamicInstructionMessages(e){return slotsOf(e,`instructions`).flatMap(({slot:e})=>{let t=e.value;return t?.role===`system`?[{content:t.content,role:`system`}]:[]})}function takeUserInstructionMessages(e){let t=readReactionsState(e),n={...t.appended},r=[],i=!1;for(let{id:t,slot:a}of slotsOf(e,`instructions`)){let e=a.value;if(e?.role!==`user`){n[t]!==void 0&&(delete n[t],i=!0);continue}n[t]!==a.digest&&(n[t]=a.digest,i=!0,r.push(createFrameworkUserMessage(`context.instruction`,e.content)))}return i&&writeReactionsState(e,{...t,appended:n}),r}export{dynamicInstructionMessages,instructionsReaction,takeUserInstructionMessages};

package/dist/src/reactions/kinds/memory.d.ts

@@ -0,0 +1,72 @@
+import type { SessionAuthContext } from "#channel/types.js";
+import type { AnchoredContext } from "#harness/current-messages.js";
+import { type JsonValue } from "#shared/json.js";
+import type { ContextContainer } from "#context/container.js";
+import type { ContextReader } from "#context/key.js";
+import type { SessionFrame } from "#dynamic/definition.js";
+import { type MemoryInstrumentation } from "#instrumentation/memory.js";
+import { type MemoryScope } from "#public/memory/index.js";
+import type { ResolvedMemoryDefinition } from "#runtime/types.js";
+import { type NormalizedMemoryRecallMessage } from "#shared/memory-state.js";
+import { type InternalContext, type Reaction } from "../reaction.js";
+export declare function bindMemoryInstrumentation(ctx: ContextContainer, instrumentation: MemoryInstrumentation | undefined): void;
+/**
+ * A memory slot's reactions. Recall runs before the first model call of each turn, and what it
+ * brings back joins what earlier turns' recalls brought: each model call reads every turn's
+ * recall just ahead of that turn's input, where earlier calls read it, so the prompt ahead of it
+ * stays cached. A message with an `id` replaces the one with that `id` an earlier turn recalled.
+ * A clear or a new scope starts over. Capture runs after the commit that completes a turn.
+ */
+export declare function memoryReactions(memory: ResolvedMemoryDefinition): readonly Reaction[];
+/**
+ * Takes the error a memory slot's capture threw for the compaction this step started: the
+ * compaction then fails before it rewrites history.
+ */
+export declare function takeCompactionCaptureFailure(ctx: object | undefined): unknown;
+/** One turn's recall, as `record` returns it. */
+interface RecallRecord {
+    /** The latest clear when it recalled: a clear starts over. */
+    readonly cleared: number | null;
+    readonly result: unknown;
+    /** The scope it recalled under: another scope starts over. */
+    readonly scope: string;
+    readonly turnId: string;
+}
+interface RecalledMessage {
+    readonly content: string;
+    readonly id?: string;
+}
+interface RecallBatch {
+    readonly turnId: string;
+    readonly messages: readonly RecalledMessage[];
+}
+/** What a slot's recalls brought, for the session so far: each turn's, in turn order. */
+interface Recalls {
+    readonly cleared: number | null;
+    readonly scope: string;
+    readonly batches: readonly RecallBatch[];
+}
+/**
+ * Joins a turn's recall to what earlier turns' recalls brought. A message with an `id` an earlier
+ * turn recalled replaces it, unless its content is the same; a recall for a turn that already has
+ * one, as on a new deployment, replaces that turn's.
+ */
+export declare function accumulate(previous: JsonValue, recalled: RecallRecord, messages: readonly NormalizedMemoryRecallMessage[]): Recalls;
+/** What the memory slots recalled, each with the turn whose input it belongs ahead of. */
+export declare function memoryRecallContents(ctx: Pick<ContextReader, "get"> | undefined): readonly AnchoredContext[];
+/** What resolving a memory slot's scope reads. */
+export interface ScopeContext {
+    readonly abortSignal: AbortSignal;
+    readonly channel: SessionFrame["channel"];
+    readonly ctx: InternalContext["ctx"];
+    readonly session: Pick<SessionFrame["session"], "auth" | "id">;
+}
+/** The scope a memory slot operates under for this session, or `null` when it's disabled. */
+export declare function resolveMemoryScope(memory: Pick<ResolvedMemoryDefinition, "namespace" | "scope" | "slot">, ctx: ScopeContext): Promise<MemoryScope | null>;
+/**
+ * Who the session acts for, as a memory selection reads it: the whole principal, since a scope
+ * tells principals apart by type, authenticator, issuer, and id, and an authored scope can read
+ * its attributes too. Two principals that share an id never share a selection.
+ */
+export declare function principalOf(ctx: Pick<SessionFrame, "session">): SessionAuthContext | null;
+export {};

package/dist/src/reactions/kinds/memory.js

@@ -0,0 +1 @@
+import{requireHistory}from"../reaction.js";import{readReactionsState,readSlot,sessionIdOf,slotsOf}from"../state.js";import{channelOf}from"../frame.js";import{effectiveModelId}from"./model.js";import{createLogger}from"#internal/logging.js";import{isEveDevEnvironment}from"#internal/application/dev-environment.js";import{parseJsonValue}from"#shared/json.js";import{buildCallbackContext}from"#context/build-callback-context.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{currentProjection}from"#harness/session-machine/current.js";import{activeTurnIdOf,latestTurnIdOf,turnCoordinatesOf}from"#protocol/session-projection.js";import{instrumentMemoryOperation}from"#instrumentation/memory.js";import{defaultNamespace}from"#public/memory/index.js";import{createMemoryScope,validateMemoryRecallResult}from"#shared/memory-state.js";const log=createLogger(`memory`),instrumentations=new WeakMap;function bindMemoryInstrumentation(e,t){t===void 0?instrumentations.delete(e):instrumentations.set(e,t)}function memoryReactions(e){let t=`memory:${e.slot}:recall`,n=[{contribute:(n,r)=>{if(n===null)return{value:null};let i=n,a=validateMemoryRecallResult(i.result,e.slot),o=accumulate(readSlot(r.ctx,t)?.value??null,i,a);return{value:o.batches.length===0?null:parseJsonValue(o)}},evaluate:async t=>{let n=readReactionsState(t.ctx).latest,r=n[`turn.started`]??null;if(r===null)return null;let i=n[`context.settled:clear`]??null;return await t.memo({cleared:i,principal:principalOf(t),turn:r},()=>recallOnce(e,t,i))},id:t,kind:`memory`,label:e.logicalPath}],r=compactionCapture(e);r!==void 0&&n.push(r);let i=e.provider.capture?.[`turn.completed`];return i===void 0?n:[...n,{id:`memory:${e.slot}:capture`,kind:`memory`,label:e.logicalPath,onCommit:async t=>{if(t.facts.find(e=>e.type===`turn.settled`&&e.data.outcome===`completed`)===void 0)return;let n=requireHistory(t,e.logicalPath),r=activeTurn(n),a=await resolveMemoryScope(e,commitScopeContext(t));if(a===null)return;let o=operationId(sessionIdOf(t.ctx),e.slot,`turn.completed`,r);try{await instrumentMemoryOperation(instrumentations.get(t.ctx),{idempotencyKey:o,operationName:`upsert_memory`,phase:`turn.completed`,slot:e.slot,storeId:a.key,turnId:r.id},async()=>(await i({...buildCallbackContext(),abortSignal:t.abortSignal,memory:{scope:a,slot:e.slot},messages:n,operationId:o,turn:r}),{value:void 0}))}catch(t){log.error(`Completed-turn memory capture failed.`,{error:t,slot:e.slot})}},timing:`commit`}]}async function recallOnce(e,t,n){let r=requireHistory(t,e.logicalPath),i=activeTurn(r),a=await resolveMemoryScope(e,t);if(a===null)return null;let o=operationId(t.session.id,e.slot,`turn.started`,i);return{cleared:n,result:await instrumentMemoryOperation(instrumentations.get(t.ctx),{idempotencyKey:o,operationName:`search_memory`,phase:`turn.started`,slot:e.slot,storeId:a.key,turnId:i.id},async()=>{let n=await e.provider.recall[`turn.started`]({...buildCallbackContext(),abortSignal:t.abortSignal,memory:{scope:a,slot:e.slot},messages:r,operationId:o,turn:i}),s=(n?.messages??[]).map(e=>e.id===void 0?{content:e.content}:{content:e.content,id:e.id});return{outputRecords:s,recordCount:s.length,value:n}})??null,scope:a.key,turnId:i.id}}function commitScopeContext(e){let t=buildCallbackContext();return{abortSignal:e.abortSignal,channel:channelOf(e.ctx),ctx:e.ctx,session:{auth:t.session.auth,id:t.session.id}}}const compactionCaptureFailures=new WeakMap;function takeCompactionCaptureFailure(e){if(e===void 0||!compactionCaptureFailures.has(e))return;let t=compactionCaptureFailures.get(e);return compactionCaptureFailures.delete(e),t??Error(`A memory capture failed.`)}function compactionCapture(e){let t=e.provider.capture?.[`compaction.requested`];if(t!==void 0)return{id:`memory:${e.slot}:compaction`,kind:`memory`,label:e.logicalPath,timing:`commit`,onCommit:async n=>{let r=n.facts.find(e=>e.type===`context.started`&&e.data.kind===`compaction`);if(r!==void 0)try{let i=requireHistory(n,e.logicalPath),a=await resolveMemoryScope(e,commitScopeContext(n));if(a===null)return;let o=r.data.turnId===void 0?null:activeTurn(i),s=[`eve-memory-operation-v1`,sessionIdOf(n.ctx),`compaction.requested`,r.data.changeId,e.slot].join(`:`);await instrumentMemoryOperation(instrumentations.get(n.ctx),{idempotencyKey:s,operationName:`upsert_memory`,phase:`compaction.requested`,slot:e.slot,storeId:a.key,...o!==null&&{turnId:o.id}},async()=>(await t({...buildCallbackContext(),abortSignal:n.abortSignal,compaction:{modelId:n.ctx.get(BundleKey)?.turnAgent.compactionModel?.id??effectiveModelId(n.ctx)??`unknown`,usageInputTokens:r.data.trigger?.inputTokens??null},memory:{scope:a,slot:e.slot},messages:i,operationId:s,turn:o}),{value:void 0}))}catch(t){log.error(`Memory capture before compaction failed; the compaction fails.`,{error:t,slot:e.slot}),compactionCaptureFailures.has(n.ctx)||compactionCaptureFailures.set(n.ctx,t)}}}}function accumulate(e,t,n){let r=e,i=r?.batches!==void 0&&r.cleared===t.cleared&&r.scope===t.scope?r.batches.filter(({turnId:e})=>e!==t.turnId):[],a=new Map;for(let e of i)for(let t of e.messages)t.id!==void 0&&a.set(t.id,t.content);let o=n.filter(({content:e,itemKey:t})=>t===void 0||a.get(t)!==e).map(({content:e,itemKey:t})=>t===void 0?{content:e}:{content:e,id:t}),s=new Set(o.flatMap(({id:e})=>e===void 0?[]:[e])),c=i.map(e=>({...e,messages:e.messages.filter(({id:e})=>e===void 0||!s.has(e))})).filter(({messages:e})=>e.length>0);return o.length>0&&c.push({messages:o,turnId:t.turnId}),{batches:c,cleared:t.cleared,scope:t.scope}}function memoryRecallContents(e){return slotsOf(e,`memory`).flatMap(({slot:e})=>(e.value?.batches??[]).flatMap(({messages:e,turnId:t})=>e.map(({content:e})=>({content:e,turnId:t}))))}async function resolveMemoryScope(e,t){let n=typeof e.scope==`function`?await e.scope({abortSignal:t.abortSignal,channel:t.channel,session:{auth:t.session.auth,id:t.session.id}}):e.scope;if(n===null)return disabled(e.slot,`scope`);let r=t.ctx.get(BundleKey),i={appRoot:r?.resolvedAgent.metadata.appRoot??``,node:r?.nodeId??`__root__`,slot:e.slot},a=e.namespace===void 0?defaultNamespace(i):typeof e.namespace==`function`?await e.namespace(i):e.namespace;return a===null?disabled(e.slot,`namespace`):createMemoryScope({namespace:a,scope:n,slot:e.slot})}function disabled(e,t){return isEveDevEnvironment()&&log.info(`Memory slot is disabled for this operation`,{resolver:t,slot:e}),null}function principalOf(e){return e.session.auth.current}function activeTurn(e){let t=currentProjection(),n=activeTurnIdOf(t)??latestTurnIdOf(t)??``,{sequence:r}=turnCoordinatesOf(t,n),i=e.length;for(;i>0&&e[i-1].role!==`user`;)--i;let a=i;for(;a>0&&e[a-1].role===`user`;)--a;return Object.freeze({id:n,input:Object.freeze(e.slice(a,i)),sequence:r})}function operationId(e,t,n,r){return[`eve-memory-operation-v1`,e,String(r.sequence),r.id.length===0?`standalone`:r.id,n,t].join(`:`)}export{accumulate,bindMemoryInstrumentation,memoryReactions,memoryRecallContents,principalOf,resolveMemoryScope,takeCompactionCaptureFailure};

package/dist/src/reactions/kinds/model.d.ts

@@ -0,0 +1,21 @@
+import type { ContextReader } from "#context/key.js";
+import { type LiveDynamicModelSelection } from "#context/keys.js";
+import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
+import { type ValueReaction } from "../reaction.js";
+/** A dynamic `model` failed to choose a model: the model call that needs it fails. */
+export declare class DynamicModelSelectionError extends Error {
+    readonly code = "EVE_DYNAMIC_MODEL_SELECTION_FAILED";
+    readonly name = "DynamicModelSelectionError";
+    constructor(error: unknown);
+}
+export declare function isDynamicModelSelectionError(error: unknown): error is DynamicModelSelectionError;
+/**
+ * An agent's dynamic `model` field: its function returns the model, as a gateway ID, a provider
+ * object, or `{ model, reasoning?, modelContextWindowTokens?, modelOptions? }`. It runs first
+ * among dynamic values, so every later one can read `ctx.model`. A model call needs a model, so
+ * `null` fails it.
+ */
+export declare function loadModelReaction(bundle: CompiledBundle): Promise<ValueReaction | undefined>;
+/** The model the next call uses: the dynamic agent's, or the static one. */
+export declare function getEffectiveModelSelection(ctx: Pick<ContextReader, "get">): LiveDynamicModelSelection | null;
+export declare function effectiveModelId(ctx: Pick<ContextReader, "get">): string | undefined;

package/dist/src/reactions/kinds/model.js

@@ -0,0 +1 @@
+import{authoredEvaluate}from"../reaction.js";import{readLive,readReactionsState,slotValueOf}from"../state.js";import{StaticModelReferenceKey}from"#context/keys.js";import{toErrorMessage}from"#shared/errors.js";import{parseJsonValue}from"#shared/json.js";import{isMockModel}from"#internal/mock-model-identity.js";import{isFrameworkDefinition}from"#dynamic/definition.js";import{loadDynamicRuntimeModelDefinition,resolveRuntimeModelSelection,shouldMockAuthoredRuntimeModels}from"#runtime/agent/resolve-model.js";const MODEL_REACTION_ID=`model:agent`,DYNAMIC_MODEL_SELECTION_ERROR_CODE=`EVE_DYNAMIC_MODEL_SELECTION_FAILED`;var DynamicModelSelectionError=class extends Error{code=DYNAMIC_MODEL_SELECTION_ERROR_CODE;name=`DynamicModelSelectionError`;constructor(e){super(toErrorMessage(e),{cause:e})}};function isDynamicModelSelectionError(e){return e instanceof DynamicModelSelectionError||typeof e==`object`&&!!e&&e.code===DYNAMIC_MODEL_SELECTION_ERROR_CODE}async function loadModelReaction(e){let t=e.turnAgent.dynamicModel;if(t===void 0)return;let n=await loadDynamicRuntimeModelDefinition({dynamicModel:t,scope:{moduleMap:e.moduleMap,nodeId:e.nodeId}}),r=`${t.logicalPath}#model`;return{contribute:async(e,{ctx:t})=>{try{return await contributionOf(e,t)}catch(e){throw new DynamicModelSelectionError(e)}},evaluate:authoredEvaluate(n.evaluate,{framework:isFrameworkDefinition(n)}),id:MODEL_REACTION_ID,kind:`model`,label:r}}async function contributionOf(e,t){let n=await resolveRuntimeModelSelection({durability:`live`,selection:e,state:t}),r=n.model===void 0||!isMockModel(n.model)&&shouldMockAuthoredRuntimeModels()?void 0:n,i={reference:n.reference};return{live:r,value:parseJsonValue(i)}}function getEffectiveModelSelection(e){let t=readReactionsState(e).slots[MODEL_REACTION_ID];if(t!==void 0&&t.value!==null)return readLive(e,MODEL_REACTION_ID,t)?.live??{reference:slotValueOf(t.value).reference};let n=e.get(StaticModelReferenceKey);return n==null?null:{reference:n}}function effectiveModelId(e){try{return getEffectiveModelSelection(e)?.reference.id}catch{return}}export{DynamicModelSelectionError,effectiveModelId,getEffectiveModelSelection,isDynamicModelSelectionError,loadModelReaction};

package/dist/src/reactions/kinds/skill.d.ts

@@ -0,0 +1,27 @@
+import type { ContextContainer } from "#context/container.js";
+import type { ContextReader } from "#context/key.js";
+import { type DynamicSkillManifest } from "#context/keys.js";
+import type { ResolvedDynamicSkillResolver } from "#runtime/types.js";
+import { type ValueReaction } from "../reaction.js";
+/**
+ * A `defineDynamic()` in `agent/skills/`: one skill named after the file, or a map of them. The
+ * slot records what the model sees: each skill's name, description, markdown, and a revision of
+ * its files. The files themselves are built again wherever a sandbox needs them, not stored.
+ */
+export declare function skillReaction(resolver: ResolvedDynamicSkillResolver): ValueReaction;
+/**
+ * The dynamic skills the session's slots hold, by reaction. A dynamic skill overrides a same-named
+ * authored one; when two reactions name the same skill, the first keeps it.
+ */
+export declare function dynamicSkillManifest(ctx: Pick<ContextReader, "get"> | undefined): DynamicSkillManifest;
+/**
+ * Queues the writes of skills with supporting files, so the model call never waits for the
+ * sandbox; anything that uses the sandbox waits for them. A package already written at its
+ * revision to the same sandbox is skipped, and a session with nothing to write or withdraw never
+ * touches the sandbox.
+ *
+ * Files are removed only when no slot holds a skill by that name anymore. A skill that stops
+ * returning supporting files keeps them, since the sandbox may already provide them, for example
+ * from its snapshot.
+ */
+export declare function syncDynamicSkillFiles(ctx: ContextContainer): Promise<void>;

package/dist/src/reactions/kinds/skill.js

@@ -0,0 +1 @@
+import{authoredEvaluate}from"../reaction.js";import{slotValueOf,slotsOf}from"../state.js";import{createLogger}from"#internal/logging.js";import{DynamicSkillSandboxKey,SandboxKey}from"#context/keys.js";import{parseJsonValue}from"#shared/json.js";import{eveNamespaceReservation}from"#protocol/runtime-tools.js";import{normalizeSkillPackage,removeSkillPackageFromSandbox,skillPackageRevision,writeSkillPackageToSandbox}from"#shared/skill-package.js";import{SKILL_NAME_PATTERN,SKILL_NAME_RULE}from"#discover/grammar.js";import{isBrandedSkillEntry}from"#shared/skill-definition.js";const log=createLogger(`dynamic-skills`);function skillReaction(e){return{contribute:t=>{let n=namedSkills(e,t).map(({entry:e,name:t})=>normalizeSkillPackage({...e,name:t}));if(n.length===0)return{value:null};let r=n.map(toDurableSkill),i=n.filter(e=>e.files.length>1);return{value:parseJsonValue(r),...i.length>0&&{live:i}}},id:`skill:${e.extensionNamespace??``}:${e.slug}`,kind:`skill`,evaluate:authoredEvaluate(e.evaluate,{framework:e.framework}),label:e.logicalPath}}function dynamicSkillManifest(e){let t={};for(let{id:n,skills:r}of ownedSkills(e,(e,t,n)=>log.error(`Dynamic skill "${e}" from "${t}" collides with "${n}".`)))r.length>0&&(t[n]=r);return t}function ownedSkills(e,t){let n=new Map;return slotsOf(e,`skill`).map(({id:e,live:r,slot:i})=>({id:e,live:r,skills:(slotValueOf(i.value)??[]).filter(r=>{let i=n.get(r.name);return i===void 0?(n.set(r.name,e),!0):(t?.(r.name,e,i),!1)})}))}async function syncDynamicSkillFiles(e){let t=e.get(SandboxKey);if(t===void 0)return;let n=new Set,r=new Map,i=new Map;for(let{live:t,skills:a}of ownedSkills(e)){let e=new Map((t??[]).map(e=>[e.name,e]));for(let t of a){if(n.add(t.name),t.revision===void 0)continue;r.set(t.name,t.revision);let a=e.get(t.name)?.files;a!==void 0&&i.set(t.name,{description:t.description,files:a,content:t.markdown,name:t.name})}}(r.size!==0||Object.keys(e.get(DynamicSkillSandboxKey)??{}).length!==0)&&t.prepare(async a=>{let o=e.get(DynamicSkillSandboxKey)??{},s=sandboxIdentity(await t.captureState()),mark=e=>`${s}#${r.get(e)??``}`,c=Object.keys(o).filter(e=>!n.has(e)),l=c.filter(e=>s!==null&&o[e]?.startsWith(`${s}#`)===!0),u=[...r.keys()].filter(e=>i.has(e)&&(s===null||o[e]!==mark(e)));if(c.length===0&&u.length===0)return;let d={...o};for(let e of c)l.includes(e)||delete d[e];if(l.length===0&&u.length===0){e.set(DynamicSkillSandboxKey,d);return}let f=await a();for(let e of l)await removeSkillPackageFromSandbox({name:e,sandbox:f}),delete d[e];for(let n of u){let a=i.get(n);if(a===void 0)continue;delete d[n],e.set(DynamicSkillSandboxKey,{...d}),await removeSkillPackageFromSandbox({name:n,sandbox:f}),await writeSkillPackageToSandbox({sandbox:f,skill:a});let o=sandboxIdentity(await t.captureState());o!==null&&(d[n]=`${o}#${r.get(n)}`)}e.set(DynamicSkillSandboxKey,d)})}function namedSkills(e,t){if(t==null)return[];let n=isBrandedSkillEntry(t),r=n?{_single:t}:t,i=e.extensionNamespace===void 0?``:`${e.extensionNamespace}__`;return Object.entries(r).map(([t,r])=>{let a=n?e.slug:`${i}${t}`,o=eveNamespaceReservation(a);if(o!==void 0)throw Error(`The defineDynamic() in "${e.logicalPath}" returned the reserved skill name "${a}". ${o}; rename the skill.`);if(!SKILL_NAME_PATTERN.test(a))throw Error(`The defineDynamic() in "${e.logicalPath}" returned illegal skill name "${a}". ${SKILL_NAME_RULE}`);return{entry:r,name:a}})}function toDurableSkill(e){let t={markdown:e.content,description:e.description,name:e.name};return e.deferred===!0&&(t.deferred=!0),e.files.length>1&&(t.revision=skillPackageRevision(e)),t}function sandboxIdentity(e){return e.session===null?null:JSON.stringify(e.session)}export{dynamicSkillManifest,skillReaction,syncDynamicSkillFiles};

package/dist/src/reactions/kinds/subagent.d.ts

@@ -0,0 +1,16 @@
+import type { ContextReader } from "#context/key.js";
+import type { DurableDynamicSubagentSelection } from "#context/keys.js";
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+import { type ResolvedDynamicSubagentResolver } from "#runtime/subagents/registry.js";
+import { type ValueReaction } from "../reaction.js";
+type Selection = Exclude<DurableDynamicSubagentSelection, null>;
+/** A dynamic `subagents/<name>/agent.ts`: `defineAgent(...)`, `defineRemoteAgent(...)`, or `null`. */
+export declare function subagentReaction(resolver: ResolvedDynamicSubagentResolver): ValueReaction;
+/**
+ * The dynamic subagents the session's slots select, by node id. A remote agent with credentials
+ * carries the binding a child opened now keeps, from which they're built again.
+ */
+export declare function readDynamicSubagentSelections(ctx: ContextReader | undefined): Readonly<Record<string, Selection>>;
+/** The model-visible tools of the selected dynamic subagents. */
+export declare function buildDynamicSubagentTools(ctx: ContextReader): readonly HarnessToolDefinition[];
+export {};

package/dist/src/reactions/kinds/subagent.js

@@ -0,0 +1 @@
+import{authoredEvaluate}from"../reaction.js";import{entryVersions,slotValueOf,slotsOf}from"../state.js";import{sessionConnectionNames}from"./connection.js";import{bindingOf}from"../remote.js";import{parseJsonValue}from"#shared/json.js";import{assertNotConnectionOwned}from"#connections/ownership.js";import{eveNamespaceReservation}from"#protocol/runtime-tools.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{normalizeDynamicRemoteAgent}from"#runtime/subagents/dynamic-remote-agent-config.js";import{createPreparedWorkflowToolHarnessDefinition}from"#execution/tools/workflow/harness-definition.js";import{normalizeDynamicSubagentAgentConfig}from"#runtime/subagents/dynamic-agent-config.js";import{createPreparedRuntimeSubagentTool}from"#runtime/subagents/registry.js";function subagentReaction(e){return{contribute:async(t,{ctx:n})=>{if(t==null)return{value:null};let{credentials:r,selection:i}=await selectionOf(n,e,t),a=parseJsonValue(JSON.parse(JSON.stringify(i)));return r===void 0?{value:a}:{live:r,value:a}},id:`subagent:${e.nodeId}`,kind:`subagent`,evaluate:authoredEvaluate(e.evaluate,{framework:e.framework}),label:e.logicalPath}}function readDynamicSubagentSelections(e){let t={};for(let{id:n,slot:r}of slotsOf(e,`subagent`)){let i=slotValueOf(r.value);if(i===null)continue;let a=n.slice(9);t[a]=i.kind===`remote`&&i.remoteAgent.credentials===!0?{...i,binding:bindingOf(e,a)}:i}return t}function buildDynamicSubagentTools(e){return slotsOf(e,`subagent`).flatMap(({id:t,slot:n})=>{let r=slotValueOf(n.value);return r===null||(r.kind===`subagent`?r.agentConfig.tool:r.remoteAgent.tool)===!1?[]:[{...createPreparedWorkflowToolHarnessDefinition(r.prepared),version:entryVersions(e,t)(n.value)}]})}async function selectionOf(e,t,n){assertNotConnectionOwned({connectionNames:sessionConnectionNames(e),name:t.name,remedy:`Rename the subagent directory.`,subject:`Dynamic subagent`});let r={logicalPath:t.logicalPath,name:t.name,nodeId:t.nodeId,sourceId:t.sourceId,sourceKind:t.sourceKind};if(n.kind===`remote`){let{config:i,credentials:a}=await normalizeDynamicRemoteAgent({name:t.name,value:n}),o=t.tool===!1?{...i,tool:!1}:i;assertToolNameAvailable(e,t,o.tool);let s={kind:`remote`,prepared:createPreparedRuntimeSubagentTool({...r,description:o.description,kind:`remote`,path:o.path,tool:o.tool,url:o.url}),remoteAgent:o};return a===void 0?{selection:s}:{credentials:a,selection:s}}let i=await normalizeDynamicSubagentAgentConfig({name:t.name,state:e,value:n}),a=t.tool===!1?{...i,tool:!1}:i;return assertToolNameAvailable(e,t,a.tool),{selection:{agentConfig:a,kind:`subagent`,prepared:createPreparedRuntimeSubagentTool({...r,description:a.description,kind:`subagent`,tool:a.tool})}}}function assertToolNameAvailable(e,t,n){let r=eveNamespaceReservation(t.name);if(r!==void 0)throw Error(`Dynamic subagent "${t.name}" from "${t.logicalPath}" uses the reserved name "${t.name}". ${r}; rename the subagent.`);if(n!==!1&&e.get(BundleKey)?.toolRegistry.toolsByName.has(t.name)===!0)throw Error(`Dynamic subagent "${t.name}" from "${t.logicalPath}" collides with the tool "${t.name}". Set the subagent's tool to false when that tool wraps it.`)}export{buildDynamicSubagentTools,readDynamicSubagentSelections,subagentReaction};

package/dist/src/reactions/kinds/tool.d.ts

@@ -0,0 +1,16 @@
+import type { ContextReader } from "#context/key.js";
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+import type { ResolvedDynamicToolResolver } from "#runtime/types.js";
+import { type ValueReaction } from "../reaction.js";
+/**
+ * A `defineDynamic()` in `agent/tools/`: one tool named after the file, or a map of them. The slot
+ * records what the model is offered; the tools themselves are code.
+ */
+export declare function toolReaction(resolver: ResolvedDynamicToolResolver): ValueReaction;
+/**
+ * Every dynamic tool the session's slots hold, in run order. The first reaction to name a tool
+ * keeps it; a later one that names it again is logged and left out.
+ */
+export declare function dynamicTools(ctx: Pick<ContextReader, "get"> | undefined): HarnessToolDefinition[];
+/** The names of the dynamic tools the session's slots hold, live or not. */
+export declare function dynamicToolNames(ctx: Pick<ContextReader, "get"> | undefined): readonly string[];

package/dist/src/reactions/kinds/tool.js

@@ -0,0 +1 @@
+import{authoredEvaluate}from"../reaction.js";import{entryVersions,slotsOf}from"../state.js";import{sessionConnectionNames}from"./connection.js";import{createLogger}from"#internal/logging.js";import{serializeInputSchema,serializeOutputSchema,toInputSchema,toOutputSchema}from"#tools/schema.js";import{assertNotConnectionOwned}from"#connections/ownership.js";import{eveNamespaceReservation}from"#protocol/runtime-tools.js";import{isBrandedToolEntry}from"#tools/dynamic.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";import{TOOL_SLUG_PATTERN,TOOL_SLUG_RULE}from"#discover/grammar.js";import{isFrameworkTool}from"#tools/provided/framework-tool.js";import{workflowIdForHandling}from"#runtime/subagents/workflow-reference.js";import{createToolExecuteWithAuth}from"#execution/tool-auth.js";import{isWorkflowToolDefinition}from"#tools/workflow-definition.js";const log=createLogger(`dynamic-tools`);function toolReaction(e){return{contribute:(t,{ctx:n})=>{let r=namedTools(e,t).map(({entry:t,name:r})=>(assertToolNameAvailable(n,e,r),liveTool(r,t)));return r.length===0?{value:null}:{live:r,value:r.map(declaration)}},id:`tool:${e.extensionNamespace??``}:${e.slug}`,kind:`tool`,evaluate:authoredEvaluate(e.evaluate,{framework:e.framework}),label:e.logicalPath}}function dynamicTools(e){let t=new Map;for(let{id:n,live:r,slot:i}of slotsOf(e,`tool`)){let a=entryVersions(e,n),o=Array.isArray(i.value)?i.value:[];for(let[e,i]of(r??[]).entries()){let r={...i,version:a(o[e]??null)};if(t.has(r.name)){log.error(`Dynamic tool "${r.name}" from "${n}" collides with another dynamic tool.`);continue}t.set(r.name,r)}}return[...t.values()]}function dynamicToolNames(e){return slotsOf(e,`tool`).flatMap(({slot:e})=>Array.isArray(e.value)?e.value.map(e=>e.name):[])}function namedTools(e,t){if(t==null)return[];let assertOrdinaryTool=t=>{if(isWorkflowToolDefinition(t))throw Error(`The defineDynamic() in "${e.logicalPath}" cannot return defineWorkflowTool(). Workflow tools must be static tools; use defineTool() for dynamic entries.`)};if(assertOrdinaryTool(t),isBrandedToolEntry(t))return[{entry:t,name:e.slug}];if(typeof t!=`object`||Array.isArray(t))throw Error(`The defineDynamic() in "${e.logicalPath}" must return defineTool(), a map of defineTool() values, or null.`);let n=e.extensionNamespace===void 0?``:`${e.extensionNamespace}__`;return Object.entries(t).map(([t,r])=>{if(assertOrdinaryTool(r),!isBrandedToolEntry(r))throw Error(`The defineDynamic() in "${e.logicalPath}" returned "${t}" without defineTool(). Wrap every dynamic tool entry in defineTool().`);let i=`${n}${t}`;if(!TOOL_SLUG_PATTERN.test(i))throw Error(`The defineDynamic() in "${e.logicalPath}" returned illegal tool name "${i}". ${TOOL_SLUG_RULE}`);let a=eveNamespaceReservation(i);if(a!==void 0)throw Error(`The defineDynamic() in "${e.logicalPath}" returned the reserved tool name "${i}". ${a}; rename the map key.`);return{entry:r,name:i}})}function assertToolNameAvailable(e,t,n){assertNotConnectionOwned({connectionNames:sessionConnectionNames(e),name:n,remedy:`Rename the map key.`,subject:`Dynamic tool`});let r=e.get(BundleKey);if(r===void 0)return;let{subagentRegistry:i,toolRegistry:a}=r;if(new Set([...[...a.toolsByName.values()].filter(({prepared:e})=>workflowIdForHandling(e.behavior?.handling)!==void 0).map(({prepared:e})=>e.name),...i.preparedTools.map(e=>e.name),...i.dynamicResolvers.map(e=>e.name)]).has(n))throw Error(`Dynamic tool "${n}" from "${t.logicalPath}" collides with the workflow tool or agent "${n}". Rename the map key.`)}function liveTool(e,t){let n=t,r=n;return{approval:n.approval,availableInSubagents:n.availableInSubagents,deferred:n.deferred,description:n.description,endsTurn:n.endsTurn,execute:createToolExecuteWithAuth({execute:(e,t)=>n.execute(e,t),scope:e}),frameworkTool:isFrameworkTool(n)||void 0,inputSchema:toInputSchema(n.inputSchema),label:r.label,name:e,outputSchema:n.outputSchema===void 0?void 0:toOutputSchema(n.outputSchema),toModelOutput:n.toModelOutput}}function declaration(e){return{description:e.description,inputSchema:serializeInputSchema(e.inputSchema),name:e.name,...e.outputSchema===void 0?{}:{outputSchema:serializeOutputSchema(e.outputSchema)},...e.deferred===!0&&{deferred:!0},...e.endsTurn===!0&&{endsTurn:!0},...e.availableInSubagents===!1&&{availableInSubagents:!1}}}export{dynamicToolNames,dynamicTools,toolReaction};

package/dist/src/reactions/policy.d.ts

@@ -0,0 +1,13 @@
+/**
+ * How the policies that answer one question combine. A policy can only restrict, so the answer
+ * is the most restrictive one and the policies' order never matters. `meet` is associative,
+ * commutative, and idempotent, and `open` restricts nothing.
+ */
+export interface Restriction<D> {
+    readonly open: D;
+    readonly meet: (a: D, b: D) => D;
+}
+/** Answers one question; the session acts on what every policy for it answered together. */
+export type Policy<Q, D> = (question: Q) => D;
+/** What `policies` answer together for `question`. */
+export declare function decide<Q, D>(law: Restriction<D>, policies: readonly Policy<Q, D>[], question: Q): D;

package/dist/src/reactions/policy.js

@@ -0,0 +1 @@
+function decide(e,t,n){return t.reduce((t,r)=>e.meet(t,r(n)),e.open)}export{decide};