@animalabs/agent-framework 0.26.1 → 0.27.0

package/src/api/server.ts

@@ -518,8 +518,7 @@ export class ApiServer {
     const contextManager = agent.getContextManager();
     // A dry run: listed, never sent, so it persists no fold resolutions and
     // queues none of the compression its fold plan calls for (see
-    // Agent.compileWithInjections for what a dry run still leaves, and for
-    // context-manager#160's thinking binding).
+    // Agent.compileWithInjections for what a dry run still leaves).
     const { messages } = await contextManager.compile(undefined, undefined, { dryRun: true });
 
     const limit = params?.limit ?? 50;

package/src/auto-continue.ts

@@ -0,0 +1,42 @@
+/**
+ * autoContinue (AgentConfig.autoContinue, docs/auto-continue.md): a turn the
+ * model ends itself is followed by another, unless it ended on a skip. This
+ * module holds what doesn't need the framework: which ends continue, and the
+ * row the next turn reads.
+ */
+
+/** The reason on a continuation's wake (InferenceRequest.reason). */
+export const AUTO_CONTINUE_REASON = 'auto-continue';
+
+/**
+ * Stop reasons of a turn the model ended itself. The others don't continue:
+ * a refusal has its own handling (retries, rewind, the reaction), a
+ * `max_tokens` end was cut off rather than chosen, and `no_progress` and
+ * `round_limit` are the stall guard's verdict that the turn wasn't moving.
+ */
+export const AUTO_CONTINUE_STOP_REASONS: ReadonlySet<string> = new Set(['end_turn', 'stop_sequence']);
+
+/**
+ * The row a continuation's turn reads. It names the agent (residents read
+ * one shared message slot), says another turn starts, says how to stop
+ * (`stop`, an imperative such as "call skip_reply") and that anything written
+ * without it is sent as usual, and, on the last continuation of a run, that
+ * the agent waits for the next event after it. When the last turn's closing
+ * words were held because that turn had already sent, it says so. Short,
+ * neutral and event-shaped on purpose: it rides as a system row in the
+ * window, where instruction blocks about output have tripped classifiers,
+ * and wording that reads as a lapse or a budget invites a published reply.
+ */
+export function autoContinueNotice(opts: {
+  agentName: string;
+  stop: string;
+  last: boolean;
+  heldAfterSend?: boolean;
+}): string {
+  return `[continue] ${opts.agentName}, another turn starts now.` +
+    (opts.heldAfterSend
+      ? ' Your closing words last turn were held, not sent: that turn had already sent with a send tool.'
+      : '') +
+    ` If you're done, ${opts.stop}; anything you write without it is sent as usual.` +
+    (opts.last ? ' This is the last continuation in a row: after this turn you wait for the next event either way.' : '');
+}

package/src/code-execution/isolate/scripts.ts

@@ -46,6 +46,10 @@ export interface ScriptCallContext {
   watch?: ScriptWatch;
   /** The call watching the script now, if one is: a result that ends the turn ends it at that call's return. Without it, `watch`. */
   watching?(): ScriptWatch | undefined;
+  /** The turn the script's run call was made in, when one was: the turn its words were written in, which a later turn's wait doesn't change. */
+  startTurnId?: number;
+  /** What its agent had read when the run call started the script (the host's consumed watermark), given at run: what the script's words were written having read, which a later round's wait doesn't change. */
+  startReadThrough?: { branch: string; sequence: number } | null;
 }
 
 export interface ScriptsHost {
@@ -113,7 +117,7 @@ interface Script {
   /** The code it runs. */
   code: string;
   run: ScriptRun;
-  context: { origin?: unknown };
+  context: { origin?: unknown; startReadThrough?: { branch: string; sequence: number } | null };
   /** The turn its run call was made in, when one was: its agent's turns end it by that. */
   turnId: number | undefined;
   startedAt: number;
@@ -176,7 +180,7 @@ export class AgentScripts {
     agentName: string,
     code: string,
     askedMs?: number,
-    options: { origin?: unknown; watch?: ScriptWatch } = {},
+    options: { origin?: unknown; watch?: ScriptWatch; startReadThrough?: { branch: string; sequence: number } | null } = {},
   ): Promise<ScriptReturn> {
     // Listed first, so a module whose tool list throws refuses the run with nothing taken.
     let tools: readonly PreludeTool[];
@@ -202,7 +206,10 @@ export class AgentScripts {
       agentName,
       code,
       run: null as unknown as ScriptRun,
-      context: options.origin === undefined ? {} : { origin: options.origin },
+      context: {
+        ...(options.origin === undefined ? {} : { origin: options.origin }),
+        ...(options.startReadThrough === undefined ? {} : { startReadThrough: options.startReadThrough }),
+      },
       turnId: options.watch?.turnId,
       startedAt: Date.now(),
       endedAt: null,
@@ -231,6 +238,7 @@ export class AgentScripts {
           ...script.context,
           ...(script.watch ? { watch: script.watch } : {}),
           watching: () => script.watch ?? undefined,
+          ...(script.turnId !== undefined ? { startTurnId: script.turnId } : {}),
         }),
       onWake: (payload, n) => this.wake(script, payload, n),
       onEnd: (ending) => this.ended(script, ending),