@animalabs/agent-framework 0.22.2 → 0.23.0

package/src/types/framework.ts

@@ -24,8 +24,6 @@ export interface ModuleProcessResponse {
 export interface ProcessLoggingConfig {
   /** Persist process logs to Chronicle (default: false) */
   persist?: boolean;
-  /** Broadcast process:completed trace events (default: false) */
-  broadcast?: boolean;
 }
 
 /**
@@ -41,7 +39,9 @@ export interface ProcessLoggingConfig {
  * the agent already has broader host access through its tools).
  */
 export interface CodeExecutionConfig {
-  /** Master switch — the tool is only synthesized when true. */
+  /** Master switch — only `true` synthesizes the tool. `create()` refuses a
+   *  value that isn't a boolean, a quoted "false" included; `null` or leaving
+   *  it out counts as off. */
   enabled: boolean;
   /** Python interpreter to spawn (default: 'python3' from PATH). */
   pythonPath?: string;
@@ -74,6 +74,23 @@ export interface CodeExecutionConfig {
   /** Max wake_agent() calls per background script (default 100); further
    *  calls raise RuntimeError inside the script. */
   maxWakesPerScript?: number;
+  /** Variables for the python interpreter beyond the operating allowlist it
+   *  inherits (see CHILD_ENV_ALLOWLIST), such as PYTHONPATH. A recipe can
+   *  `${VAR}`-substitute them from .env. Other host variables aren't
+   *  inherited, which limits what model-authored code inherits, not what a
+   *  process running as the same user can read. The runner sets
+   *  PYTHONUNBUFFERED and PYTHONIOENCODING last, over any value given here,
+   *  since its protocol needs both. The interpreter's working directory is
+   *  its own runtime directory, so a relative path given here, as in
+   *  PYTHONPATH, resolves there: give absolute paths. */
+  env?: Record<string, string>;
+  /** The interpreter inherits the host's whole environment instead of the
+   *  allowlist: every host variable, provider keys included, reaches
+   *  model-authored code and every subprocess a script starts. Listing what
+   *  scripts need in `env` is the safer route. With code execution enabled,
+   *  `create()` refuses any value but true, false or null, which counts as
+   *  not set. */
+  inheritEnv?: boolean;
 }
 
 /** See `FrameworkConfig.providerHold`. */
@@ -210,7 +227,9 @@ export interface FrameworkConfig {
 
   /**
    * Client-side programmatic tool calling (`code_execution` tool). Omitted or
-   * `enabled: false` → tool absent, no python is ever spawned.
+   * `enabled: false` → tool absent, no python is ever spawned. At runtime,
+   * untyped configs may also use `null` or `false` to omit this setting.
+   * Other values that aren't objects are refused at `create()`.
    */
   codeExecution?: CodeExecutionConfig;
 
@@ -411,20 +430,32 @@ export interface InferenceLogEntry {
   requestId: string;
   /** Whether inference succeeded */
   success: boolean;
-  /** Error message if failed */
+  /** Why it didn't succeed: the failure's message, or what stopped it */
   error?: string;
-  /** Request data or blob ID if large */
+  /** Request data or blob ID if large. A stream the framework ended at a
+   *  tool boundary (stopReason 'turn_ended', 'context_budget' or
+   *  'physical_window') records a note in place of the body. */
   request: unknown | { blobId: string };
   /** Response data or blob ID if large (only if successful) */
   response?: unknown | { blobId: string };
   durationMs: number;
+  /** The stream's usage: its final response's, or, for a stream that ended
+   *  without one, the provider rounds it finished before it ended. Exactly
+   *  one entry of a stream carries it, the one its end wrote, a stop's
+   *  included; a stream whose end writes none (a superseded stream, a
+   *  disposed agent's stream) gets a failure entry that carries it, when it
+   *  had finished a round. One that hadn't has nothing to carry and gets no
+   *  entry. */
   tokenUsage?: {
     input: number;
     output: number;
     cacheCreation?: number;
     cacheRead?: number;
   };
-  /** Stop reason from the model */
+  /** Stop reason from the model, or why the framework ended the stream at a
+   *  tool boundary: 'turn_ended' (a tool result with endTurn), or
+   *  'context_budget' / 'physical_window' (a context-budget or
+   *  physical-window restart). */
   stopReason?: string;
 }
 

package/src/types/inference-log.ts

@@ -17,7 +17,7 @@ export interface InferenceLogQuery {
   offset?: number;
   /** Search pattern for content (regex) */
   pattern?: string;
-  /** Only show failures */
+  /** Only show inferences that didn't succeed: failed or stopped */
   errorsOnly?: boolean;
 }
 

package/src/types/module.ts

@@ -15,17 +15,43 @@ import type { TraceEventListener } from './trace.js';
 export interface MessageQuery {
   /** Filter by external source (e.g., 'discord') */
   source?: string;
+  /** Filter by external IDs: messages whose metadata.external.id is one of these. An empty list filters nothing. */
+  externalIds?: string[];
   /** Filter by participant name */
   participant?: string;
-  /** Filter by metadata fields (shallow match) */
+  /** Filter by metadata fields: each key a path, dot-separated for a nested
+   *  field (such as 'external.channelId'), its value compared by strict
+   *  equality */
   metadata?: Record<string, unknown>;
 }
 
+/**
+ * A message as a module context's reads answer it: a stored row, or a row
+ * for a write the framework holds (`held`).
+ */
+export type ModuleMessage = StoredMessage & {
+  /**
+   * True while the framework holds the message's write, as it does while
+   * the write's agent has a turn alive or the host is quiesced, until a
+   * later boundary stores it. The row's `id` is then a handle, which
+   * getMessage, editMessage and removeMessage take as they take a stored
+   * id, and which names the stored row once the write lands. Its `sequence`
+   * and `timestamp` are provisional: the sequence comes after every stored
+   * row's, the timestamp is when the framework held the write (for a write
+   * an older release held, when its queue was read back), and both change
+   * when it lands. Absent on a stored row.
+   */
+  held?: true;
+};
+
 /**
  * Result of a message query.
  */
 export interface MessageQueryResult {
-  messages: StoredMessage[];
+  /** The matching stored rows, then, as the newest, the matching rows of
+   *  writes the framework holds (ModuleMessage.held): before the stored rows
+   *  in a reversed query */
+  messages: ModuleMessage[];
   totalCount: number;
 }
 
@@ -53,7 +79,12 @@ export interface Module {
 
   /**
    * Stop the module.
-   * Called when the framework stops or when the module is removed.
+   * Called when the framework stops or when the module is removed. Also called
+   * when a create() that started the module fails (#389): create() stops the
+   * framework before it rejects, so before the host has it and before anything
+   * a host wires up after create() returns, such as a WorkspaceModule's
+   * initStore(). A stop() that saves state can therefore run before that
+   * wiring, and shouldn't then save over state it was handed and hasn't used.
    */
   stop(): Promise<void>;
 
@@ -184,8 +215,11 @@ export interface ModuleContext {
    * `modules/<module>/<name>`. Idempotent — safe to call on every start().
    * Items are appended with `appendToLog` (one O(item) record per append) and
    * point-edited with `editLogItem`; Chronicle's append_log snapshot cadence
-   * handles consolidation. `name` must not be 'state' (reserved for the main
-   * snapshot state) and must not contain '/'.
+   * handles consolidation. The cadence applies when the state is first
+   * registered: a store that already holds the state keeps the cadence it was
+   * registered with. `name` must not be 'state' (reserved for the main
+   * snapshot state) and must not contain '/'. A registration that fails
+   * throws, naming the state, and leaves the name unregistered.
    */
   registerLogState(
     name: string,
@@ -239,7 +273,14 @@ export interface ModuleContext {
   getModule<T extends Module>(name: string): T | null;
 
   /**
-   * Add a message to the conversation.
+   * Add a message to the conversation, and answer its id. While the
+   * framework holds the write (the agent's turn is alive, or the host is
+   * quiesced), the id is a handle, `held:` and the write's id, which
+   * getMessage, editMessage and removeMessage take as they take a stored
+   * id, and which names the stored row once the write lands
+   * (ModuleMessage.held). The writes a process held, and keeps across a
+   * restart, show to the next process's modules once create() has restored
+   * them, which is after every module's start().
    */
   addMessage(
     participant: string,
@@ -248,28 +289,40 @@ export interface ModuleContext {
   ): MessageId;
 
   /**
-   * Edit a message.
+   * Edit a message, by its id or a held write's handle. A held write is
+   * stored with the new content.
    */
   editMessage(id: MessageId, content: ContentBlock[]): void;
 
   /**
-   * Remove a message.
+   * Remove a message, by its id or a held write's handle. A held write is
+   * dropped, so the agent never reads it.
    */
   removeMessage(id: MessageId): void;
 
   /**
-   * Find a message by external ID.
+   * Find the message for an external ID this context added a message under:
+   * the row it added, while the store holds it. For a write the framework
+   * held, whose id this context doesn't keep, the first row the store shows
+   * under that external ID, held rows included, a held row by its handle.
+   * Null when this context added none under it, when the row it added is
+   * gone, or when the store shows none for a held write, such as one the
+   * last process held, looked up in start().
    */
   findMessageByExternalId(source: string, externalId: string): MessageId | null;
 
   /**
-   * Get a message by ID.
+   * Get a message by its id or a held write's handle.
    */
-  getMessage(id: MessageId): StoredMessage | null;
+  getMessage(id: MessageId): ModuleMessage | null;
 
   /**
    * Query messages by filter criteria.
    * Useful for finding messages from external sources, by participant, etc.
+   * The rows of writes the framework holds come after the stored rows, as
+   * the newest, or before them in a reversed query, marked `held`
+   * (ModuleMessage). Those the last process held show once create() has
+   * restored them, after every module's start() (addMessage).
    */
   queryMessages(filter: MessageQuery): MessageQueryResult;
 
@@ -322,7 +375,8 @@ export interface ModuleContext {
    * Modules use this to react to agent lifecycle without polling — e.g. an
    * adapter that wants to show a "typing" indicator can bracket it between
    * `inference:started` and the terminal events: `inference:completed` (the
-   * normal end), `inference:turn_ended` (a tool result ended the turn),
+   * model answered and the turn ended, with a final response or with a tool
+   * result that ended it, which `inference:turn_ended` then follows),
    * `inference:aborted`, `inference:failed` and `inference:exhausted`, all of
    * which carry `agentName`. A turn's tool-call cycles stay inside its
    * stream, so one bracket spans them. A context-budget restart emits
@@ -436,12 +490,14 @@ export interface EventResponse {
   addMessages?: NewMessage[];
 
   /**
-   * Messages to edit.
+   * Messages to edit, each by its id or a held write's handle
+   * (ModuleContext.editMessage).
    */
   editMessages?: MessageEdit[];
 
   /**
-   * Messages to remove.
+   * Messages to remove, each by its id or a held write's handle
+   * (ModuleContext.removeMessage).
    */
   removeMessages?: MessageId[];
 
@@ -512,6 +568,15 @@ export interface SpeechContext {
    * Empty when no tool calls were made.
    */
   thoughts?: ContentBlock[];
+
+  /**
+   * The turn this speech ends: the same id as `ToolCall.callerTurnId` on the
+   * calls made in it (its model's calls and its foreground scripts' inner
+   * calls), kept across the turn's streams (a context-budget restart or a
+   * retry), and larger for the agent's next turn. Unique only within one run
+   * of the process.
+   */
+  turnId?: number;
 }
 
 /**

package/src/types/trace.ts

@@ -1,6 +1,7 @@
 import type { ProcessEvent } from './events.js';
 import type { ModuleProcessResponse } from './framework.js';
 import type { SessionUsage } from '../usage/types.js';
+import type { DraftReason } from '../prose-drafts.js';
 
 /**
  * Base for all trace events.
@@ -55,6 +56,12 @@ export type TraceEvent =
       silent?: boolean;
     })
   | (TraceEventBase & {
+      /**
+       * The model answered and the turn ended: with the stream's final
+       * response, or with a tool result carrying `endTurn`, which
+       * `inference:turn_ended` then follows. `tokenUsage` is the stream's
+       * usage, cumulative across its rounds.
+       */
       type: 'inference:completed';
       agentName: string;
       durationMs: number;
@@ -66,11 +73,13 @@ export type TraceEvent =
       /** How long this start of the turn ran; after a context-budget restart, from the restart. */
       durationMs: number;
       /**
-       * Why the turn ended unfinished: the reason an operator gave
-       * `abortInference`, `'quiesce_abandoned'` for a turn an operator quiesce
-       * abandoned, or, for a turn dropped before it sent anything (its agent
-       * replaced or removed, or the framework stopping or restarted), a
-       * sentence saying which.
+       * Why the turn ended unfinished: the reason its canceller gave
+       * `abortInference` or `Agent.cancelStream` (`'user'` when it gave
+       * none), `'shutdown'` for a turn `stop()` cancelled,
+       * `'quiesce_abandoned'` for a turn an operator quiesce abandoned, or,
+       * for a turn dropped before it sent anything (its agent replaced or
+       * removed, or the framework stopping or restarted), a sentence saying
+       * which.
        */
       reason?: string;
     })
@@ -304,7 +313,13 @@ export type TraceEvent =
       messageId?: string;
     })
   /** RFC-006 coalescing decision record (received / displaced / removed /
-   *  rendered / revoked / render-cancelled / late-render / render-failed). */
+   *  rendered / revoked / render-cancelled / late-render / render-failed).
+   *  A late-render whose push/render had already timed out, its fallback
+   *  materialized, is recorded by the connection's wiring rather than the
+   *  coalescer: it names `serverId`, `featureSet`, `key` and, for a
+   *  channel-scoped subject, `channelId` instead of `subject`, carries a late
+   *  JSON-RPC error as `error` (`[code] message`, bounded), and its `eventId`
+   *  links it to the batch's render-failed. */
   | (TraceEventBase & {
       type: 'mcpl:coalescing';
       kind: string;
@@ -455,6 +470,9 @@ export type TraceEvent =
       channelId: string;
       reason: string;
       textLen: number;
+      /** `failed`: nothing was posted; `unknown`: the request was dispatched
+       *  and no valid receipt came back, so it may have been. */
+      outcome?: 'failed' | 'unknown';
     })
 
   // Admin puppet: an operator executed a tool AS an agent and stored the
@@ -570,10 +588,51 @@ export type TraceEvent =
       suggestion?: string;
       hint: string;
     })
+  | (TraceEventBase & {
+      /** An inbound RPC request/notification handler failed: it threw or
+       *  rejected, or it resolved after a reply write of its own failed or
+       *  after it tried to answer a second time. */
+      type: 'mcpl:request-handler-error';
+      serverId: string;
+      /** Connection event name, e.g. channels-register or push-event. */
+      event: string;
+      /** The request's id when it is a number, or a string id bounded as the
+       *  other texts here are: control, format and line-separator characters
+       *  replaced, and cut after 500 code points, with "…" marking the cut.
+       *  Absent for a notification, for a request whose id is neither, and
+       *  for a request form of mcpl/manifestChanged or
+       *  notifications/tools/list_changed, which is answered as it's admitted
+       *  and then handled as the notification is. */
+      requestId?: string | number;
+      /** Whether a reply write of the handler's returned: true once one
+       *  did. On a connection that had already closed, that write dropped
+       *  the reply, as the connection then drops every reply, so nothing
+       *  reached the server. A write that throws, as one that can't be
+       *  encoded does, sends nothing. When it's false and the responder
+       *  can send an error reply (it has respondError), the host sent -32603
+       *  "Internal error" itself, or -32000 while it stops, unless
+       *  `responseError` says that reply failed. A connection that has
+       *  already closed drops that reply, as it drops every reply, with no
+       *  `responseError`. */
+      responseAttempted: boolean;
+      /** The handler's own error when it threw or rejected; otherwise the
+       *  reply write that failed and that it swallowed, or that it tried to
+       *  answer a second time. */
+      error: string;
+      /** A reply write that failed, when the handler then failed with an
+       *  error of its own (which is `error`). */
+      responseFailure?: string;
+      /** What the handler tried to send after a reply was already attempted:
+       *  refused, never written. A result, or an error reply with its code
+       *  and (bounded) message. */
+      refusedResponse?: { kind: 'result' } | { kind: 'error'; code: number; message: string };
+      /** Failure while trying to send the internal-error response. */
+      responseError?: string;
+    })
   | (TraceEventBase & {
       type: 'mcpl:orphaned-response';
       serverId: string;
-      /** The JSON-RPC id of the late response whose pending request already timed out. */
+      /** The JSON-RPC id of the late response, whose request had already timed out or been ended by its transport's close. */
       responseId: string | number;
       /** Original request method when retained for mandatory-deadline visibility. */
       method?: string;
@@ -581,6 +640,8 @@ export type TraceEvent =
       hadState: boolean;
       /** True when the dropped response carried a server-managed `checkpoint`. */
       hadCheckpoint: boolean;
+      /** A late JSON-RPC error, as `[code] message`, bounded. */
+      error?: string;
     })
 
   // Ops / fleet observability. Everything the framework's opsAlert() escalates
@@ -613,7 +674,7 @@ export type TraceEvent =
       parkedAdmissions?: number;
       /** True when undrained turns were force-cancelled (abandon). */
       abandoned?: boolean;
-      /** Agents whose turn abandon could not cancel (token held, no stream). */
+      /** Agents whose turn the abandon had not ended when its grace ran out: a token held with no stream and no check ahead (a puppet tool turn, a store surgery's reservation, a turn finishing its last delivery), or a turn that hadn't reached its next check, the tool-result guard's wait for its speech included. A turn whose stream the abandon cancelled while it was still streaming isn't listed, even one still running when the grace ran out. */
       unabandonable?: string[];
     })
   | (TraceEventBase & {
@@ -627,6 +688,40 @@ export type TraceEvent =
       type: 'host:quiesced_boot';
       reason?: string;
       since?: number;
+    })
+
+  // Inbound acceptance observation (mcpl/inbound-source.ts): an installed
+  // InboundAcceptanceObserver threw. Delivery is unaffected; the observer's
+  // own coverage is interrupted for that acceptance.
+  | (TraceEventBase & {
+      type: 'inbound:observer-failed';
+      /** Envelope kind of the acceptance the observer failed on. */
+      kind: 'channel' | 'unscoped' | 'surface';
+      error: string;
+    })
+
+  // Held prose drafts (src/prose-drafts.ts): plain speech kept privately
+  // instead of sent; a resident's explicit resend; a deliberate dismissal.
+  | (TraceEventBase & {
+      type: 'prose:drafts-held';
+      agentName: string;
+      reason: DraftReason;
+      draftIds: string[];
+      textLen: number;
+    })
+  | (TraceEventBase & {
+      type: 'prose:draft-resent';
+      agentName: string;
+      draftId: string;
+      status: 'delivered' | 'failed' | 'unknown';
+      serverId: string;
+      channelId: string;
+      messageId?: string;
+    })
+  | (TraceEventBase & {
+      type: 'prose:drafts-dismissed';
+      agentName: string;
+      draftIds: string[];
     });
 
 /**

package/src/usage/usage-tracker.ts

@@ -12,10 +12,14 @@ function accumulateUsage(
   tokens: { inputTokens: number; outputTokens: number; cacheCreationTokens: number; cacheReadTokens: number },
   estimatedCost?: { total: number; currency: string }
 ): void {
-  target.inputTokens += tokens.inputTokens;
-  target.outputTokens += tokens.outputTokens;
-  target.cacheCreationTokens += tokens.cacheCreationTokens;
-  target.cacheReadTokens += tokens.cacheReadTokens;
+  // A provider's usage can lack a count (membrane 0.5.87's Bedrock stream
+  // takes a message_delta's output count as reported); adding it would make
+  // the total NaN, which is stored as null.
+  const count = (n: number): number => (Number.isFinite(n) ? n : 0);
+  target.inputTokens += count(tokens.inputTokens);
+  target.outputTokens += count(tokens.outputTokens);
+  target.cacheCreationTokens += count(tokens.cacheCreationTokens);
+  target.cacheReadTokens += count(tokens.cacheReadTokens);
   if (estimatedCost) {
     if (!target.estimatedCost) {
       target.estimatedCost = { total: 0, currency: estimatedCost.currency };
@@ -31,10 +35,16 @@ function accumulateUsage(
 function parseUsage(raw: unknown): SessionUsage | null {
   if (!raw || typeof raw !== 'object') return null;
   const o = raw as Record<string, unknown>;
-  if (typeof o.inputTokens !== 'number' || typeof o.outputTokens !== 'number') return null;
+  // A count stored as null is a NaN total, as JSON stores one: an earlier
+  // release could write it when a provider's usage lacked a count. The sum
+  // before it was lost when it became NaN, so it reads as 0.
+  const count = (v: unknown): number | undefined => (v === null ? 0 : typeof v === 'number' ? v : undefined);
+  const inputTokens = count(o.inputTokens);
+  const outputTokens = count(o.outputTokens);
+  if (inputTokens === undefined || outputTokens === undefined) return null;
   return {
-    inputTokens: o.inputTokens,
-    outputTokens: o.outputTokens as number,
+    inputTokens,
+    outputTokens,
     cacheCreationTokens: typeof o.cacheCreationTokens === 'number' ? o.cacheCreationTokens : 0,
     cacheReadTokens: typeof o.cacheReadTokens === 'number' ? o.cacheReadTokens : 0,
     estimatedCost: o.estimatedCost && typeof o.estimatedCost === 'object'
@@ -49,6 +59,18 @@ export interface PersistedUsageState {
   inferenceCount: number;
 }
 
+/** What keeps a stored usage record from restoring, or undefined when it
+ *  restores: it must be an object whose totals are token counts and whose
+ *  byAgent, if it has one, is a list. Its per-agent entries are checked one
+ *  by one as they restore, and one that isn't an agent's usage is skipped. */
+export function persistedUsageProblem(value: unknown): 'not a record' | 'totals' | 'byAgent' | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return 'not a record';
+  const { totals, byAgent } = value as { totals?: unknown; byAgent?: unknown };
+  if (parseUsage(totals) === null) return 'totals';
+  if (byAgent !== undefined && !Array.isArray(byAgent)) return 'byAgent';
+  return undefined;
+}
+
 export class UsageTracker {
   private totals: SessionUsage = { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
   private byAgent: Map<string, { usage: SessionUsage; inferenceCount: number }> = new Map();
@@ -71,7 +93,9 @@ export class UsageTracker {
     this.totals = totals;
     this.inferenceCount = typeof state.inferenceCount === 'number' ? state.inferenceCount : 0;
     if (Array.isArray(state.byAgent)) {
-      for (const entry of state.byAgent) {
+      for (const item of state.byAgent as unknown[]) {
+        if (!item || typeof item !== 'object') continue;
+        const entry = item as { agentName?: unknown; usage?: unknown; inferenceCount?: unknown };
         const usage = parseUsage(entry.usage);
         if (usage && typeof entry.agentName === 'string') {
           this.byAgent.set(entry.agentName, {

package/dist/test/activation-request-sanitize.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=activation-request-sanitize.test.d.ts.map

package/dist/test/activation-request-sanitize.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"activation-request-sanitize.test.d.ts","sourceRoot":"","sources":["../../test/activation-request-sanitize.test.ts"],"names":[],"mappings":""}

package/dist/test/activation-request-sanitize.test.js

@@ -1,89 +0,0 @@
-/**
- * Live-path empty-text sanitize (PR #58, 8a89da0): the Anthropic API rejects
- * empty text blocks with a 400, and one such block in the compiled window used
- * to mute the agent entirely — [inference-failed] on every activation until
- * the offending message aged out (field-observed 2026-07-10). The sanitize in
- * buildActivationRequest strips empty/whitespace/non-string text blocks and
- * drops messages left with no content, BEFORE the trailing-assistant check.
- */
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { Agent } from '../src/agent.js';
-/** buildActivationRequest only needs compile(); membrane is never touched. */
-function agentCompiling(messages) {
-    const cm = {
-        compile: async () => ({ messages, systemInjections: [] }),
-    };
-    return new Agent({ name: 'tester', model: 'test-model', systemPrompt: 'sys' }, cm, {});
-}
-describe('buildActivationRequest empty-text sanitize', () => {
-    it('strips empty and whitespace-only text blocks, keeps real text', async () => {
-        const agent = agentCompiling([
-            {
-                participant: 'human',
-                content: [
-                    { type: 'text', text: '' },
-                    { type: 'text', text: '   \n\t ' },
-                    { type: 'text', text: 'hello' },
-                ],
-            },
-        ]);
-        const request = await agent.buildActivationRequest([]);
-        assert.equal(request.messages.length, 1);
-        assert.deepEqual(request.messages[0].content, [{ type: 'text', text: 'hello' }]);
-    });
-    it('strips text blocks whose `text` is not a string (untyped history from disk)', async () => {
-        const agent = agentCompiling([
-            {
-                participant: 'human',
-                content: [
-                    { type: 'text', text: null },
-                    { type: 'text', text: 42 },
-                    { type: 'text', text: 'kept' },
-                ],
-            },
-        ]);
-        const request = await agent.buildActivationRequest([]);
-        assert.deepEqual(request.messages[0].content, [{ type: 'text', text: 'kept' }]);
-    });
-    it('drops a message left with no content at all', async () => {
-        const agent = agentCompiling([
-            { participant: 'human', content: [{ type: 'text', text: '' }] },
-            { participant: 'human', content: [{ type: 'text', text: 'still here' }] },
-        ]);
-        const request = await agent.buildActivationRequest([]);
-        assert.equal(request.messages.length, 1);
-        assert.deepEqual(request.messages[0].content, [{ type: 'text', text: 'still here' }]);
-    });
-    it('passes non-text blocks through untouched — tool pairing is unaffected', async () => {
-        const toolUse = { type: 'tool_use', id: 't1', name: 'shell', input: {} };
-        const toolResult = { type: 'tool_result', toolUseId: 't1', content: 'ok' };
-        const agent = agentCompiling([
-            { participant: 'human', content: [{ type: 'text', text: 'run it' }] },
-            // Tool-only assistant turn whose accompanying text block is empty: the
-            // exact shape that produced the field incident.
-            { participant: 'tester', content: [{ type: 'text', text: '' }, toolUse] },
-            { participant: 'user', content: [toolResult] },
-            { participant: 'human', content: [{ type: 'text', text: 'and?' }] },
-        ]);
-        const request = await agent.buildActivationRequest([]);
-        assert.equal(request.messages.length, 4);
-        assert.deepEqual(request.messages[1].content, [toolUse]);
-        assert.deepEqual(request.messages[2].content, [toolResult]);
-    });
-    it('runs BEFORE the trailing-assistant check: a sanitize-exposed trailing assistant still gets [Continue]', async () => {
-        const agent = agentCompiling([
-            { participant: 'human', content: [{ type: 'text', text: 'hi' }] },
-            { participant: 'tester', content: [{ type: 'text', text: 'ok' }] },
-            // Empty trailing user message: dropped by the sanitize, which leaves the
-            // assistant turn last — the [Continue] guard must see THAT shape.
-            { participant: 'human', content: [{ type: 'text', text: '  ' }] },
-        ]);
-        const request = await agent.buildActivationRequest([]);
-        assert.equal(request.messages.length, 3);
-        const last = request.messages[request.messages.length - 1];
-        assert.equal(last.participant, 'user');
-        assert.deepEqual(last.content, [{ type: 'text', text: '[Continue]' }]);
-    });
-});
-//# sourceMappingURL=activation-request-sanitize.test.js.map

package/dist/test/activation-request-sanitize.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"activation-request-sanitize.test.js","sourceRoot":"","sources":["../../test/activation-request-sanitize.test.ts"],"names":[],"mappings":"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"}

package/dist/test/agent-cache-ttl.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=agent-cache-ttl.test.d.ts.map

package/dist/test/agent-cache-ttl.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-cache-ttl.test.d.ts","sourceRoot":"","sources":["../../test/agent-cache-ttl.test.ts"],"names":[],"mappings":""}