experimental-a2 0.19.0 → 0.21.1

package/src/store.ts

@@ -2,7 +2,7 @@
  * The A2Store interface — the storage contract every store backend
  * implements. See specs/a2-implementation.md §2–3.
  *
- * This is the whole storage contract: append, read, dispatch claims,
+ * This is the whole storage contract: append, read, consumer cursors,
  * failure markers, snapshots, and the live stream. The scheduler
  * needs nothing extra — the armed queue message is its own state, and
  * the store is the only thing it consults.
@@ -21,58 +21,102 @@ export type Event = {
   createdAt: Date
 }
 
-/** The handler dispatch whose append first persisted a child event. */
+/** The consumer attempt whose append first persisted a child event. */
 export type EventCause = {
+  consumer: string
+  /** The cursor's lane; null for a concurrent consumer's cursor of one event. */
+  lane: string | null
   index: number
   attempt: number
-  /** Size of one named handler append, used to reject truncated retries. */
+  /** Size of one named consumer append, used to reject truncated retries. */
   batchSize?: number
 }
 
-/**
- * What the store persists: immutable event history, including its causal edge,
- * plus derived dispatch and failure bookkeeping. The bookkeeping is disposable;
- * the event and its cause are not.
- */
+/** What the store persists: immutable event history and its causal edge. */
 export type StoredEvent = Event & {
-  /** Same-session handler dispatch that appended this event; null means root. */
+  /** Same-session consumer attempt that appended this event; null means root. */
   cause: EventCause | null
-  /** Session-scoped serial execution key resolved when the event is appended. */
+}
+
+/**
+ * Where a consumer's cursor stands on its head event. A cursor is one record
+ * per (session, consumer, lane): a log cursor for a consumer with one string
+ * lane, a lane cursor per lane for a lane function, and a cursor per event
+ * (lane null) for a concurrent consumer. Its attempt and failure fields
+ * describe the current head and reset when the cursor moves past it.
+ */
+export type HeadDispatch = {
+  consumer: string
   lane: string | null
-  /** Adapter clock time recorded by append settlement, completion, or manual skip; null while pending. */
-  processedAt: Date | null
-  /** Dispatch attempt that completed this event; null without dispatch or while pending. */
-  processedByAttempt: number | null
-  /** Exact ordered child ids atomically returned by the completing attempt. */
-  returnedEventIds: string[] | null
-  /** Adapter clock time recorded by the first durable dispatch claim. */
+  /** Adapter clock time recorded by the first durable claim of this head. */
   firstClaimedAt: Date | null
-  /** Adapter clock time recorded by the most recent durable dispatch claim. */
+  /** Adapter clock time recorded by the most recent durable claim of this head. */
   lastClaimedAt: Date | null
-  /** Durable dispatch claims, including claims abandoned by hard kills. */
+  /** Durable claims of this head, including claims abandoned by hard kills. */
   attemptCount: number
-  /** Current dispatch holder; null when the event is not claimed. */
+  /** Current holder; null when the head is not claimed. */
   claimHolder: string | null
   /**
-   * Adapter clock expiry for the current dispatch claim, or, with no holder,
-   * the end of a failed attempt's retry hold.
+   * Adapter clock expiry for the current claim, or, with no holder, the end
+   * of a failed attempt's retry hold.
    */
   claimExpiresAt: Date | null
   /**
-   * Failed attempts: caught handler failures, and lapsed claims a later claim
-   * took over. This alone drives dead-lettering.
+   * Failed attempts on this head: caught failures, and lapsed claims a later
+   * claim took over. This alone drives dead-lettering.
    */
   failureCount: number
-  /** Adapter clock time recorded by the most recent caught handler failure. */
+  /** Adapter clock time recorded by the most recent caught failure. */
   lastFailedAt: Date | null
-  /** Dispatch attempt that produced the most recent caught handler failure. */
+  /** Attempt that produced the most recent caught failure. */
   lastFailedAttempt: number | null
-  /** The last handler failure, stringified. */
+  /** The last failure, stringified. */
   lastError: string | null
   /** Adapter clock time recorded when dead-lettered; null otherwise. */
   failedAt: Date | null
-  /** Latest clear marker, on claimed events of a cleared session. */
-  clearIndex?: number
+}
+
+/** Where one cursor stands: its position, its head, and the head's dispatch state. */
+export type StoredCursor = HeadDispatch & {
+  /** The last index this cursor finished; a log cursor counts from the latest clear marker. */
+  position: number
+  /** The event it runs next; null when it has nothing to run. */
+  head: number | null
+}
+
+/** A cursor's head event together with its dispatch state. */
+export type HeadEvent = StoredEvent &
+  HeadDispatch & {
+    /** Latest clear marker, on claimed heads of a cleared session. */
+    clearIndex?: number
+  }
+
+/** Names one cursor head: the consumer, its lane, and the head's index. */
+export type HeadRef = {
+  consumer: string
+  lane: string | null
+  index: number
+}
+
+/**
+ * A consumer the caller serves. Work for consumers it does not name is
+ * neither pending nor claimed, so a removed consumer's cursors wait for its
+ * name to return.
+ */
+export type StoreConsumer = {
+  name: string
+  /**
+   * Set for a consumer with one string lane. Its cursor keeps one position
+   * over the log and runs the next event whose type is in `types` (null:
+   * every type). A missing cursor is created by the first append that
+   * carries one of those types: at the start of the log with `backfill`,
+   * otherwise just before that append.
+   */
+  log?: {
+    lane: string
+    types: readonly string[] | null
+    backfill: boolean
+  }
 }
 
 /**
@@ -106,8 +150,8 @@ export type StoreStateRead = {
 export type StoreSnapshotWrite = {
   index: number
   state: unknown
-  /** Unfinished trigger events that durably retain this exact checkpoint. */
-  pinEventIndexes?: readonly number[]
+  /** Unfinished cursor heads that durably retain this exact checkpoint. */
+  pins?: readonly HeadRef[]
 }
 
 export type StoreStateReadRequest = {
@@ -115,9 +159,15 @@ export type StoreStateReadRequest = {
   throughIndex?: number
   snapshotThroughIndex?: number
 }
-/** The result of atomically claiming every currently eligible event. */
+
+/** The result of atomically claiming every currently eligible head. */
 export type StoreClaimAvailableResult =
-  | { outcome: 'claimed'; events: StoredEvent[] }
+  | {
+      outcome: 'claimed'
+      events: HeadEvent[]
+      /** The session's head when the claim was made: how far behind each event is. */
+      head?: number
+    }
   | { outcome: 'busy'; retryAt: Date }
   | { outcome: 'settled' }
 
@@ -125,48 +175,61 @@ export type StoreClaimAvailableResult =
 export type CompleteAttemptResult =
   { outcome: 'completed'; events: StoredEvent[] } | { outcome: 'superseded' }
 
-/** The result of one claim-renewal heartbeat, both lists in append order. */
+/** The result of one claim-renewal heartbeat, both lists in head order. */
 export type RenewClaimsResult = {
   /** Listed claims that remain owned by the holder. */
-  renewed: number[]
-  /** Listed claims whose event a newer attempt has durably taken. */
-  superseded: number[]
+  renewed: HeadRef[]
+  /** Listed claims a newer attempt has durably taken, or whose cursor moved on. */
+  superseded: HeadRef[]
 }
 
-/** The result of atomically recording a caught handler failure. */
+/** The result of atomically recording a caught failure. */
 export type FailAttemptResult = {
   outcome: 'failed' | 'dead_lettered' | 'superseded'
   failureCount: number
 }
 
+/** A consumer an appended event starts work for, with its resolved lane. */
+export type EventTarget = {
+  consumer: string
+  /** The lane a lane function resolved; null runs the event concurrently. */
+  lane: string | null
+}
+
 /** Input to `A2Store.append` — already validated by the machine. */
 export type AppendEvent = {
   type: string
   payload: unknown
   /** Caller-supplied idempotency key; generated when absent. */
   id?: string
-  /** Internal causal edge supplied atomically by handler `session.append`. */
+  /** Internal causal edge supplied atomically by consumer `session.append`. */
   cause?: EventCause
-  /** Session-scoped serial execution key resolved before persistence. */
-  lane?: string
-  /** Internal hint: settle this event in the append transaction; no handler is registered. */
-  settled?: true
+  /**
+   * Lane-function and concurrent consumers this event starts work for,
+   * resolved before persistence. Log-cursor consumers are matched by type
+   * from `StoreConsumer.log` instead.
+   */
+  targets?: readonly EventTarget[]
 }
 
-/** A handler-returned event with the deterministic id retries require. */
+/** A consumer-returned event with the deterministic id retries require. */
 export type ReturnedEvent = AppendEvent & { id: string }
 
 /** The rows written by an append and the session's pending state. */
 export type StoreAppendResult = {
   events: StoredEvent[]
-  /** Whether the session contains an event without a completion marker. */
+  /**
+   * Whether a served consumer has a live head in this session: one that is
+   * not dead-lettered. An append whose own batch starts work for a served
+   * consumer may report true without checking that work is runnable.
+   */
   hasPending: boolean
 }
 
 export type StoreClearOptions = {
   sessionId: string
   ifLastIndex?: number
-  /** The clearing handler's dispatch, fenced like a handler append. */
+  /** The clearing consumer's attempt, fenced like a consumer append. */
   cause?: EventCause
 }
 
@@ -182,15 +245,17 @@ export type StoreReclaimResult = { deleted: number; done: boolean }
 
 export type StoreRedriveOptions = {
   sessionId: string
+  consumer: string
   index: number
-  /** `retry` clears the dead letter; `skip` settles it without a handler. */
+  /** `retry` clears the dead letter; `skip` moves the cursor past it. */
   action: 'retry' | 'skip'
+  consumers?: readonly StoreConsumer[]
 }
 
 export type StoreRedriveResult = {
-  /** Whether the event was dead-lettered and this operation resolved it. */
+  /** Whether the head was dead-lettered and this operation resolved it. */
   redriven: boolean
-  /** Whether the session contains an event without a completion marker. */
+  /** Whether a served consumer has a live head in this session: one that is not dead-lettered. */
   hasPending: boolean
 }
 
@@ -212,6 +277,20 @@ export const SYSTEM_CLOCK: Clock = {
 
 export const RANDOM_IDS: IdSource = () => crypto.randomUUID()
 
+/**
+ * Cursor rules every operation shares:
+ *
+ * - `consumers` names the consumers the caller serves. Omitted, every cursor
+ *   counts and no log cursor is created or advanced by type.
+ * - A cursor's head is the next event it runs: the lowest unfinished event of
+ *   its lane, the event itself for a concurrent cursor, or for a log cursor
+ *   the next event after its position whose type it takes. The clear marker
+ *   is never a head.
+ * - A head is eligible when no live claim or retry hold owns it, it is not
+ *   dead-lettered, and it lies above the latest clear marker.
+ * - Moving a cursor past its head resets the head's attempt and failure
+ *   fields and releases snapshot pins on it.
+ */
 export interface A2Store {
   /**
    * Accepts a batch; the batch is atomic — one transaction, consecutive
@@ -221,18 +300,24 @@ export interface A2Store {
    * lost — return the existing rows as success. If only *some* ids
    * exist, the caller mixed an already-sent batch with fresh events —
    * always a caller bug — so throw `A2Error('PARTIAL_DUPLICATE_BATCH')`.
-   * Events carrying `settled: true` get `processedAt` in this same atomic
-   * operation, with no dispatch claim or `processedByAttempt`. The result's
-   * `hasPending` reflects the whole session in the same atomic operation,
-   * including older events and idempotent retries.
    *
-   * An event carrying `cause` is a handler append, fenced by attempt
-   * currency: accept it only while `cause.attempt` is still the parent
-   * event's latest attempt and the parent is not dead-lettered; otherwise
-   * throw `A2Error('SUPERSEDED_ATTEMPT')` and write nothing. The check is
-   * part of this atomic operation and must serialize against a concurrent
-   * `claimAvailable` — an unlocked read of the parent admits write skew.
-   * The idempotent-replay path runs first, so a batch whose ids all exist
+   * In the same atomic operation, each event's `targets` start cursor work:
+   * a lane target queues the event in that consumer's lane, a null lane
+   * creates a cursor for that event alone. Each log consumer in `consumers`
+   * whose types the batch carries gets its cursor created or, when idle, a
+   * head: the next event after its position that it takes, which may
+   * precede the batch when an appender that doesn't serve it wrote in
+   * between. `hasPending` reflects the whole session for the served consumers,
+   * including older work and idempotent retries.
+   *
+   * An event carrying `cause` is a consumer append, fenced by attempt
+   * currency: accept it only while the cause's cursor still has
+   * `cause.index` as its head, `cause.attempt` is that head's latest
+   * attempt, and the head is not dead-lettered; otherwise throw
+   * `A2Error('SUPERSEDED_ATTEMPT')` and write nothing. The check is part of
+   * this atomic operation and must serialize against a concurrent
+   * `claimAvailable` — an unlocked read of the cursor admits write skew. The
+   * idempotent-replay path runs first, so a batch whose ids all exist
    * replays regardless of the current attempt.
    *
    * Clearing stores (a2-implementation.md §17.2) fence one level earlier:
@@ -243,118 +328,162 @@ export interface A2Store {
   append(
     sessionId: string,
     events: AppendEvent[],
-    options?: { originIndex?: number },
+    options?: {
+      originIndex?: number
+      consumers?: readonly StoreConsumer[]
+    },
   ): Promise<StoreAppendResult>
 
   /**
    * Optional with `reclaim`. Serialized with `append`: checks
    * `ifLastIndex` against the head and the latest marker, then appends a
-   * settled clear marker at the next index without touching existing
-   * rows. Afterwards every event at or below the marker is superseded.
+   * clear marker at the next index without touching existing rows.
+   * Afterwards every event at or below the marker is superseded: no head
+   * lies there, and every log cursor's position counts from the marker.
    */
   clear?(options: StoreClearOptions): Promise<StoreClearResult>
 
   /**
    * Deletes one bounded batch of rows below the latest clear marker, with
-   * their bookkeeping, id records, and cached folds. `done` once nothing
+   * their cursor records, id records, and cached folds. `done` once nothing
    * remains below it. Never waits on a lock that other operations hold.
    */
   reclaim?(sessionId: string): Promise<StoreReclaimResult>
 
   /**
-   * Optional with `redrive`. The session's dead-lettered events above the
-   * latest clear marker, oldest first.
+   * Optional with `redrive`. The session's dead-lettered heads above the
+   * latest clear marker, in event order, then by consumer name.
    */
-  deadLetters?(sessionId: string): Promise<StoredEvent[]>
+  deadLetters?(sessionId: string): Promise<HeadEvent[]>
 
   /**
-   * Optional with `deadLetters`. Atomically resolves one dead-lettered event
-   * above the latest clear marker; any other event is untouched and reports
-   * `redriven: false`. `retry` clears `failedAt` and `failureCount`, so the
-   * event is claimable again with a fresh failure budget, keeping its claim
-   * history and last failure. `skip` records `processedAt` with no
-   * `processedByAttempt` or `returnedEventIds` and exposes the next event in
-   * its lane. Both serialize with `claimAvailable` and the handler-append
-   * parent fence; `skip` also serializes with lane promotion in `append` and
-   * `completeAttempt`. `hasPending` is read in the same step.
+   * Optional with `deadLetters`. Atomically resolves the consumer's
+   * dead-lettered head at `index` above the latest clear marker; anything
+   * else is untouched and reports `redriven: false`. `retry` clears
+   * `failedAt` and `failureCount`, so the head is claimable again with a
+   * fresh failure budget, keeping its claim history and last failure. `skip`
+   * moves the cursor past the head with no completion. Both serialize with
+   * `claimAvailable` and the consumer-append fence. `hasPending` is read in
+   * the same step.
    */
   redrive?(options: StoreRedriveOptions): Promise<StoreRedriveResult>
 
+  /**
+   * Brings one log consumer's cursor up to date without an append, for
+   * `session.consume()`. A missing cursor is created: with `backfill`, at
+   * the latest clear marker, taking the first event of its types after it;
+   * otherwise at the head, with nothing to run. When the session has nothing
+   * after its latest clear (or was never written), a missing cursor stays
+   * missing: nothing is written, and the cursor comes back idle at the
+   * marker, so a consume of an unknown session leaves no trace. That is
+   * exact with `backfill`; without it, the consumer starts at the first
+   * consume or serving append that finds events. An
+   * idle cursor takes the next event of its types after its position, so it
+   * finds events appended by deployments that don't serve it. A cursor with
+   * a head, claimed or not, is left as it is. Records the consumer's types,
+   * as an append would, and returns the cursor and the session's head.
+   */
+  wakeLog(options: {
+    sessionId: string
+    consumer: StoreConsumer & { log: NonNullable<StoreConsumer['log']> }
+  }): Promise<{ cursor: StoredCursor; head: number }>
+
+  /**
+   * The session's cursors: every log and lane cursor, and every concurrent
+   * cursor that still has a head, by consumer, then lane (concurrent cursors
+   * last, by head). Lane and concurrent cursors whose work lies at or below
+   * the latest clear marker are not listed.
+   */
+  cursors(sessionId: string): Promise<StoredCursor[]>
+
   /** Events for one session, oldest first. Bounds form `(afterIndex, throughIndex]`. */
   read(
     sessionId: string,
     opts?: { afterIndex?: number; throughIndex?: number },
   ): Promise<StoredEvent[]>
 
-  /** Public history without dispatch metadata; core falls back to read when absent. */
+  /** Public history without causal edges; core falls back to read when absent. */
   readHistory?(
     sessionId: string,
     opts?: { afterIndex?: number; throughIndex?: number },
   ): Promise<Event[]>
 
   /**
-   * Atomically claims every eligible pending event. Unlaned events are all
-   * independently eligible. Within a lane, only the lowest-index unfinished
-   * event is eligible. A live claim produces `busy` only when it is the sole
-   * remaining obstacle to actionable work. Claimed events are returned in event-log
-   * order. Excluded rows remain lane barriers.
+   * Atomically claims every eligible head of the served consumers. A live
+   * claim or retry hold produces `busy` only when it is the sole remaining
+   * obstacle to actionable work. Claimed heads are returned in event order,
+   * then by consumer name. Excluded heads stay unclaimed and keep blocking
+   * their lane.
    */
   claimAvailable(options: {
     sessionId: string
     holder: string
     ttlMs: number
     expiresAtMs?: number
-    excludeIndexes?: readonly number[]
+    exclude?: readonly HeadRef[]
+    consumers?: readonly StoreConsumer[]
     /**
      * Taking over a lapsed claim (one whose holder is still recorded, never
      * completed or failed) adds one to `failureCount`. When that reaches
-     * `maxFailures`, the event dead-letters instead of being claimed: it
+     * `maxFailures`, the head dead-letters instead of being claimed: it
      * comes back in `events` with `failedAt` set and no claim. Its
      * `attemptCount` still advances, fencing the lapsed attempt, and its
      * `lastFailedAttempt` is unchanged.
      */
     maxFailures?: number
+    /**
+     * Claims only heads at or below this index: a head past it is neither
+     * claimed nor reported `busy`, and stays claimable without it.
+     */
+    through?: number
   }): Promise<StoreClaimAvailableResult>
 
   /**
    * Renews the listed live claims still owned by `holder`. Each listed claim
-   * carries the attempt ordinal the holder owns. `renewed` lists the claims
-   * that remain owned after the operation; `superseded` lists the claims
-   * whose event's `attemptCount` has durably passed the listed attempt. An
-   * expired claim no successor has taken appears in neither list — its
+   * carries the attempt the holder owns. `renewed` lists the claims that
+   * remain owned after the operation; `superseded` lists the claims whose
+   * head a newer attempt has durably taken, or whose cursor has moved past
+   * it. An expired claim no successor has taken appears in neither list — its
    * attempt may still complete (`completeAttempt` is the fence), so it is
    * not reported as lost. Renewal never revives an expired claim.
    */
   renewClaims(options: {
     sessionId: string
     holder: string
-    claims: readonly { index: number; attempt: number }[]
+    claims: readonly (HeadRef & { attempt: number })[]
     ttlMs: number
     expiresAtMs?: number
   }): Promise<RenewClaimsResult>
 
   /**
-   * Atomically completes one current attempt and appends its returned events.
-   * Retrying a committed completion with the same attempt and deterministic
-   * child ids returns the existing children. A stale attempt never appends.
+   * Atomically completes one current attempt: appends its returned events
+   * (with their own targets, waking the served log consumers) and moves the
+   * cursor past its head. Retrying a committed completion with the same
+   * attempt and deterministic child ids returns the existing children. A
+   * stale attempt never appends.
    */
   completeAttempt(options: {
     sessionId: string
+    consumer: string
+    lane: string | null
     index: number
     attempt: number
     events: ReturnedEvent[]
+    consumers?: readonly StoreConsumer[]
   }): Promise<CompleteAttemptResult>
 
   /**
    * Atomically records a caught failure for one claimed attempt. A stale
-   * attempt cannot poison a processed event or a newer dispatch. Accepted
+   * attempt cannot poison a finished head or a newer attempt. Accepted
    * failures record the operation's clock time. A failure that does not
-   * dead-letter releases the claim and, with `retryAfterMs`, keeps the event
+   * dead-letter releases the claim and, with `retryAfterMs`, keeps the head
    * unclaimable for that long: its claim expiry is set with no holder, so
    * `claimAvailable` reports it `busy` until then.
    */
   failAttempt(options: {
     sessionId: string
+    consumer: string
+    lane: string | null
     index: number
     attempt: number
     error: string
@@ -389,9 +518,10 @@ export interface A2Store {
 
   /**
    * Atomically writes disposable reducer checkpoints. The greatest index
-   * advances the head cache. Older checkpoints survive only when at least one
-   * listed trigger event is still unfinished; completion and dead-lettering
-   * release that event's pins and collect unreferenced historical checkpoints.
+   * advances the head cache. Older checkpoints survive only while at least
+   * one listed cursor head is still unfinished; moving that cursor past it
+   * or dead-lettering it releases the pin and collects unreferenced
+   * historical checkpoints.
    */
   putSnapshots(
     sessionId: string,

package/src/telemetry.ts

@@ -18,6 +18,7 @@ export type A2SpanName =
   | 'a2.state'
   | 'a2.snapshot'
   | 'a2.redrive'
+  | 'a2.consume'
   | 'a2.ai.control'
   | 'a2.ai.ack'
   | 'a2.ai.generate'
@@ -30,7 +31,7 @@ export type A2SpanHandle = {
   setAttribute(key: string, value: A2AttributeValue): void
   /**
    * Mark the span failed without a2's control flow throwing — used for
-   * handler failures, which a2 swallows by design (they go into the
+   * consumer failures, which a2 swallows by design (they go into the
    * retry machinery, not up the stack) but telemetry must still see.
    */
   recordError(error: unknown): void

package/src/wire.ts

@@ -314,6 +314,7 @@ const ERROR_STATUS: Record<A2ServerErrorCode, number> = {
   STORE_NOT_CONFIGURED: 500,
   UNKNOWN_PRESENCE_FIELD: 400,
   PRESENCE_NOT_SUPPORTED: 500,
+  CONSUMER_DEAD_LETTERED: 500,
 }
 
 export function errorStatus(code: A2ErrorCode): number {

package/dist/ai-harness-BuuC-gJ3.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai-harness-BuuC-gJ3.js","names":[],"sources":["../src/ai-harness.ts"],"sourcesContent":["import {\n  createDownload,\n  type Experimental_SandboxSession,\n  type FileUIPart,\n  type FinishReason,\n  type LanguageModelUsage,\n  type ToolSet,\n  type UIMessage,\n  type UIMessageChunk,\n} from 'ai'\nimport type {\n  GenerationCompletedPayload,\n  MessageCreatedPayload,\n  ReasoningLevel,\n  ToolResultPayload,\n} from './ai.ts'\nimport { STEERED_REASON } from './ai-control.ts'\nimport { boundedCache, type BoundedCache } from './bounded-cache.ts'\nimport type { ContractEvent, EventDefs } from './contract.ts'\n\ndeclare const harnessBrand: unique symbol\n\n/**\n * A coding agent's own loop for `agent({ harness })`, from `fx()` or `pi()`.\n * `Tools` names the tools the harness brings, which `toolRecovery` may name.\n */\nexport type Harness<\n  Type extends 'fx' | 'pi' = 'fx' | 'pi',\n  Tools extends string = string,\n> = {\n  readonly type: Type\n  readonly [harnessBrand]: { readonly tools: Tools }\n}\n\n/** What a harness's sandbox resolver receives for one step or tool execution. */\nexport type HarnessSandboxContext = {\n  session: { readonly id: string }\n  signal: AbortSignal\n}\n\n/** Resolves the AI SDK sandbox session for an agent session, the same one every time. */\nexport type HarnessSandbox = (\n  context: HarnessSandboxContext,\n) => Experimental_SandboxSession | Promise<Experimental_SandboxSession>\n\n/** What a harness step streams, as the default generator does. */\nexport type HarnessGeneration = {\n  stream: ReadableStream<UIMessageChunk>\n  completion: () => { finishReason?: FinishReason; usage?: LanguageModelUsage }\n}\n\n/** One stored snapshot and the log after it, read in one store operation. */\nexport type HarnessLogRead = {\n  snapshot: { index: number; state: unknown } | null\n  events: ContractEvent<EventDefs>[]\n}\n\n/** The session log as a harness step reads it, plus the state saved in it. */\nexport type HarnessLog = {\n  /** The latest saved state under `name` and the log after it; `fresh` reads it all. */\n  read(options: {\n    name: string\n    throughIndex: number\n    fresh?: boolean\n  }): Promise<HarnessLogRead>\n  write(options: { name: string; index: number; state: unknown }): Promise<void>\n}\n\n/** Everything one durable generation hands its harness. */\nexport type HarnessStep = {\n  agentName: string\n  sessionId: string\n  requestIndex: number\n  /** This attempt at the generation. */\n  generationId: string\n  responseMessageId: string\n  /** The log index this step's context was read through. */\n  throughIndex: number\n  /** The transcript through that index. */\n  messages: readonly UIMessage[]\n  model: string\n  reasoning?: ReasoningLevel\n  speed?: 'fast' | 'standard'\n  instructions: string[]\n  tools: ToolSet\n  log: HarnessLog\n  signal: AbortSignal\n}\n\n/** The internal side of a harness value. */\nexport type HarnessDriver = {\n  /** The session's sandbox; every local tool execution receives it. */\n  readonly sandbox?: HarnessSandbox\n  /** Tools the harness brings; A2 executes them like the agent's own. */\n  readonly tools: ToolSet\n  step(step: HarnessStep): Promise<HarnessGeneration>\n}\n\n// A global symbol, so harness values work across separately bundled copies.\nconst DRIVER = Symbol.for('experimental-a2.ai.harness')\n\nexport function defineHarness<\n  Type extends 'fx' | 'pi',\n  Tools extends string = never,\n>(type: Type, driver: HarnessDriver): Harness<Type, Tools> {\n  const harness = { type }\n  Object.defineProperty(harness, DRIVER, { value: driver })\n  return Object.freeze(harness) as unknown as Harness<Type, Tools>\n}\n\nexport function harnessDriver(harness: unknown): HarnessDriver {\n  const driver =\n    typeof harness === 'object' && harness !== null\n      ? (harness as { [DRIVER]?: HarnessDriver })[DRIVER]\n      : undefined\n  if (driver === undefined)\n    throw new TypeError(\n      \"harness must be { type: 'ai-sdk' }, or come from fx() or pi()\",\n    )\n  return driver\n}\n\n// ------------------------------------------------------- saved state\n\n/**\n * What an agent's steps saved in this process at the end of a response, per\n * session and harness. A cache: a cold process rebuilds from the whole log.\n */\nexport type HarnessStates = BoundedCache<\n  string,\n  { index: number; state: unknown }\n>\n\nexport const harnessStates = (): HarnessStates =>\n  boundedCache({ maxEntries: 1_000, maxBytes: 64 * 1024 * 1024 })\n\nconst savedKey = (sessionId: string, name: string): string =>\n  `${sessionId}\\u0000${name}`\n\n// Binary state counts its bytes; everything else its JSON text.\nconst sizeOf = (value: unknown): number => {\n  let binary = 0\n  const text = JSON.stringify(value, (_key, item: unknown) => {\n    if (!(item instanceof Uint8Array)) return item\n    binary += item.byteLength\n    return null\n  })\n  return binary + (text?.length ?? 0)\n}\n\n/**\n * The session log as a harness step reads it: the state this process saved\n * at the end of the last response, when it has one, and the log after it.\n * Saved states are copied in and out, so a step cannot change one in place.\n */\nexport function harnessLog(options: {\n  states: HarnessStates\n  session: {\n    readonly id: string\n    history(bounds: {\n      gte?: number\n      lte?: number\n    }): Promise<ContractEvent<EventDefs>[]>\n  }\n}): HarnessLog {\n  const { states, session } = options\n  return {\n    read: async ({ name, throughIndex, fresh }) => {\n      const entry = fresh ? undefined : states.get(savedKey(session.id, name))\n      const snapshot =\n        entry === undefined || entry.index > throughIndex\n          ? null\n          : { index: entry.index, state: structuredClone(entry.state) }\n      const events = await session.history(\n        snapshot === null\n          ? { lte: throughIndex }\n          : { gte: snapshot.index + 1, lte: throughIndex },\n      )\n      return { snapshot, events }\n    },\n    write: async ({ name, index, state }) => {\n      const copy = structuredClone(state)\n      states.set(\n        savedKey(session.id, name),\n        { index, state: copy },\n        sizeOf(copy),\n      )\n    },\n  }\n}\n\nconst agentStates = new WeakMap<object, HarnessStates>()\n\n/** Registers an agent server's saved harness states, for `savedHarnessState`. */\nexport function registerHarnessStates(\n  server: object,\n  states: HarnessStates,\n): void {\n  agentStates.set(server, states)\n}\n\n/** What an agent's process saved for one session's harness; tests read it. */\nexport function savedHarnessState(\n  server: object,\n  options: { sessionId: string; name: string },\n): { index: number; state: unknown } | undefined {\n  return agentStates.get(server)?.get(savedKey(options.sessionId, options.name))\n}\n\n/** A harness's state at the end of a response, from the attempt that ran it. */\ntype SavedEnvelope = {\n  generationId: string\n  responseMessageId: string\n  state: unknown\n}\n\nexport type HarnessRead<S> = {\n  /** The state saved at the end of the last response, when it is usable. */\n  saved: S | undefined\n  turns: HarnessTurn[]\n  results: Map<string, ToolResultPayload>\n}\n\n/**\n * Reads a harness's saved state and the log since, as turns to replay. A\n * snapshot counts only when the attempt that wrote it committed: a stopped,\n * superseded, or still-running attempt can write one the log never kept.\n * `replayAll` reads the whole log instead, for a state that fails to restore.\n */\nexport async function readHarness<S>({\n  step,\n  name,\n  parse,\n}: {\n  step: HarnessStep\n  name: string\n  parse: (state: unknown) => S | undefined\n}): Promise<HarnessRead<S> & { replayAll: () => Promise<HarnessRead<S>> }> {\n  const replayAll = async (): Promise<HarnessRead<S>> => {\n    const read = await step.log.read({\n      name,\n      throughIndex: step.throughIndex,\n      fresh: true,\n    })\n    return { saved: undefined, ...harnessTurns(step, read.events, undefined) }\n  }\n  const read = await step.log.read({ name, throughIndex: step.throughIndex })\n  if (read.snapshot === null)\n    return {\n      saved: undefined,\n      ...harnessTurns(step, read.events, undefined),\n      replayAll,\n    }\n  const envelope = savedEnvelope(read.snapshot.state)\n  const saved = envelope === undefined ? undefined : parse(envelope.state)\n  const committed =\n    envelope !== undefined &&\n    read.events.some(\n      (event) =>\n        event.type === 'ai.generation.completed' &&\n        (event.payload as { generationId?: unknown }).generationId ===\n          envelope.generationId,\n    )\n  // A snapshot of this very response belongs to an earlier attempt at it.\n  if (\n    saved === undefined ||\n    !committed ||\n    envelope.responseMessageId === step.responseMessageId\n  )\n    return { ...(await replayAll()), replayAll }\n  return {\n    saved,\n    ...harnessTurns(step, read.events, envelope.responseMessageId),\n    replayAll,\n  }\n}\n\n/** Saves a harness's state at the end of a response; losing it costs a longer replay. */\nexport async function saveHarness({\n  step,\n  name,\n  state,\n}: {\n  step: HarnessStep\n  name: string\n  state: unknown\n}): Promise<void> {\n  const envelope: SavedEnvelope = {\n    generationId: step.generationId,\n    responseMessageId: step.responseMessageId,\n    state,\n  }\n  try {\n    await step.log.write({ name, index: step.requestIndex, state: envelope })\n  } catch {\n    // The snapshot is a cache.\n  }\n}\n\nfunction savedEnvelope(value: unknown): SavedEnvelope | undefined {\n  if (typeof value !== 'object' || value === null) return undefined\n  const { generationId, responseMessageId, state } = value as Record<\n    string,\n    unknown\n  >\n  return typeof generationId === 'string' &&\n    typeof responseMessageId === 'string'\n    ? { generationId, responseMessageId, state }\n    : undefined\n}\n\n// ------------------------------------------------- the log as harness turns\n\n/** A completed generation as the log recorded it. */\nexport type RecordedGeneration = {\n  chunks: UIMessageChunk[]\n  completed: GenerationCompletedPayload\n}\n\n/** What user messages hand a harness: their text, and the files they attach. */\nexport type HarnessInput = { text: string; files: FileUIPart[] }\n\n/** One harness turn to rebuild: its prompt, completed generations, and end. */\nexport type HarnessTurn = {\n  prompt: HarnessInput\n  generations: RecordedGeneration[]\n  /** Steering that entered after the generation at that index. */\n  steers: Map<number, HarnessInput[]>\n  end: 'stop' | 'interrupted' | 'live'\n}\n\n/**\n * Groups the log since a harness snapshot into harness turns. A response\n * steered after a step continues its turn, with the next response's prompt as\n * steering. `covered` is the response the snapshot already holds.\n */\nexport function harnessTurns(\n  step: HarnessStep,\n  events: readonly ContractEvent<EventDefs>[],\n  covered: string | undefined,\n): { turns: HarnessTurn[]; results: Map<string, ToolResultPayload> } {\n  type Generation = {\n    id: string\n    chunks: UIMessageChunk[]\n    completed?: GenerationCompletedPayload\n  }\n  type Response = {\n    id: string\n    prompt: HarnessInput[]\n    generations: Generation[]\n    end?: 'stop' | 'steered' | 'interrupted'\n  }\n  // Prompts take their content from the transcript: a harness agent never\n  // runs A2's compaction, so the step's messages hold every input admitted by\n  // its read, before the snapshot or after it. A session another loop\n  // compacted can't move to a harness.\n  const userInput = new Map<string, HarnessInput>(\n    step.messages\n      .filter((message) => message.role === 'user')\n      .map((message) => [message.id, inputOf(message)]),\n  )\n  let passive: string[] = []\n  const responses = new Map<string, Response>()\n  const byStart = new Map<number, Generation>()\n  const byId = new Map<string, Generation>()\n  const results = new Map<string, ToolResultPayload>()\n\n  for (const event of events) {\n    const payload = event.payload as Record<string, unknown>\n    switch (event.type) {\n      case 'ai.message.created': {\n        const admitted = event.payload as MessageCreatedPayload\n        if (admitted.role === 'user' && admitted.generate === false)\n          passive.push(admitted.messageId)\n        break\n      }\n      case 'ai.generation.requested': {\n        const id = payload['responseMessageId'] as string\n        if (id === covered || responses.has(id)) break\n        const messageId = payload['messageId'] as string\n        const ids = [...passive.filter((p) => p !== messageId), messageId]\n        passive = []\n        responses.set(id, {\n          id,\n          prompt: ids.flatMap((p) => userInput.get(p) ?? []),\n          generations: [],\n        })\n        break\n      }\n      case 'ai.generation.started': {\n        const response = responses.get(payload['responseMessageId'] as string)\n        if (response === undefined) break\n        const generation: Generation = {\n          id: payload['generationId'] as string,\n          chunks: [],\n        }\n        response.generations.push(generation)\n        byStart.set(event.index, generation)\n        byId.set(generation.id, generation)\n        break\n      }\n      case 'ai.generation.progress':\n        byStart\n          .get(payload['startIndex'] as number)\n          ?.chunks.push(...(payload['chunks'] as UIMessageChunk[]))\n        break\n      case 'ai.generation.completed': {\n        const generation = byId.get(payload['generationId'] as string)\n        if (generation)\n          generation.completed = event.payload as GenerationCompletedPayload\n        break\n      }\n      case 'ai.tool.result':\n        if (payload['preliminary'] !== true)\n          results.set(\n            payload['toolCallId'] as string,\n            event.payload as ToolResultPayload,\n          )\n        break\n      case 'ai.message.completed': {\n        const response = responses.get(payload['messageId'] as string)\n        if (response) response.end = 'stop'\n        break\n      }\n      case 'ai.message.interrupted': {\n        const response = responses.get(payload['messageId'] as string)\n        if (response)\n          response.end =\n            payload['reason'] === STEERED_REASON ? 'steered' : 'interrupted'\n        break\n      }\n    }\n  }\n\n  const turns: HarnessTurn[] = []\n  let steered = false\n  for (const response of responses.values()) {\n    const input: HarnessInput = {\n      text: response.prompt.map((prompt) => prompt.text).join('\\n\\n'),\n      files: response.prompt.flatMap((prompt) => prompt.files),\n    }\n    let turn = turns.at(-1)\n    if (steered && turn !== undefined) {\n      const at = Math.max(0, turn.generations.length - 1)\n      turn.steers.set(at, [...(turn.steers.get(at) ?? []), input])\n    } else {\n      turn = { prompt: input, generations: [], steers: new Map(), end: 'live' }\n      turns.push(turn)\n    }\n    for (const generation of response.generations)\n      if (generation.completed !== undefined)\n        turn.generations.push({\n          chunks: generation.chunks,\n          completed: generation.completed,\n        })\n    turn.end =\n      response.id === step.responseMessageId\n        ? 'live'\n        : response.end === 'stop'\n          ? 'stop'\n          : 'interrupted'\n    steered = response.end === 'steered'\n  }\n  return { turns, results }\n}\n\nfunction inputOf(message: UIMessage): HarnessInput {\n  return {\n    text: message.parts\n      .flatMap((part) => (part.type === 'text' ? [part.text] : []))\n      .join('\\n'),\n    files: message.parts.filter(\n      (part): part is FileUIPart => part.type === 'file',\n    ),\n  }\n}\n\n// ------------------------------------------------------------- attachments\n\n/** An attached image as an engine takes it: its bytes in base64. */\nexport type HarnessImage = { mediaType: string; data: string }\n\n// What one message's files hold in a step's memory, at most.\nconst MAX_ATTACHMENT_BYTES = 32 * 1024 * 1024\n\ntype Attachment = { data: string; bytes: number }\n\n// Every step of a response replays its turn, and a URL's file doesn't change,\n// so the process keeps what it fetched.\nconst attachments = boundedCache<string, Attachment>({\n  maxEntries: 256,\n  maxBytes: 64 * 1024 * 1024,\n})\n\n/**\n * The images an input attaches, as its engine takes them: engines take\n * bytes, not URLs. A file it can't attach fails the step, naming the file,\n * and is never left out: the failure may pass, and the step is retried like\n * any other.\n */\nexport async function harnessImages({\n  harness,\n  input,\n  signal,\n}: {\n  /** As the error names it: `fx()` or `pi()`. */\n  harness: string\n  input: HarnessInput\n  signal: AbortSignal\n}): Promise<HarnessImage[]> {\n  const images: HarnessImage[] = []\n  let budget = MAX_ATTACHMENT_BYTES\n  // One at a time, so the budget bounds what the step holds.\n  for (const file of input.files) {\n    try {\n      if (!file.mediaType.startsWith('image/'))\n        throw new Error(`it takes images only, not ${file.mediaType}`)\n      const attached = await attachment({ url: file.url, budget, signal })\n      budget -= attached.bytes\n      images.push({\n        mediaType: file.mediaType,\n        data: attached.data,\n      })\n    } catch (error) {\n      if (signal.aborted) throw error\n      throw new Error(\n        `${harness} couldn't attach ${file.filename ?? 'a file'}: ${\n          error instanceof Error ? error.message : String(error)\n        }`,\n        { cause: error },\n      )\n    }\n  }\n  return images\n}\n\nasync function attachment({\n  url,\n  budget,\n  signal,\n}: {\n  url: string\n  budget: number\n  signal: AbortSignal\n}): Promise<Attachment> {\n  const tooLarge = () =>\n    new Error(\n      `a message's files may hold ${MAX_ATTACHMENT_BYTES / 1024 / 1024} MiB in a step`,\n    )\n  const cached = attachments.get(url)\n  if (cached !== undefined) {\n    if (cached.bytes > budget) throw tooLarge()\n    return cached\n  }\n  const { protocol } = new URL(url)\n  if (protocol !== 'https:' && protocol !== 'data:')\n    throw new Error(`attachments must be https: or data: URLs, not ${protocol}`)\n  // AI SDK's download checks an https: URL's address and its redirects,\n  // which a message's sender chooses; a data: URL holds its bytes.\n  const bytes =\n    protocol === 'data:'\n      ? dataBytes(url)\n      : (\n          await createDownload({ maxBytes: budget })({\n            url: new URL(url),\n            abortSignal: signal,\n          })\n        ).data\n  if (bytes.byteLength > budget) throw tooLarge()\n  const attached: Attachment = {\n    data: Buffer.from(bytes).toString('base64'),\n    bytes: bytes.byteLength,\n  }\n  if (protocol === 'https:')\n    attachments.set(url, attached, attached.data.length)\n  return attached\n}\n\nfunction dataBytes(url: string): Uint8Array {\n  const comma = url.indexOf(',')\n  if (comma === -1) throw new Error('its data: URL has no data')\n  const body = url.slice(comma + 1)\n  return url.slice(0, comma).endsWith(';base64')\n    ? Buffer.from(body, 'base64')\n    : Buffer.from(decodeURIComponent(body))\n}\n\n// ------------------------------------------------------------- Gateway\n\nexport type GatewayCredential = { token: string; method: 'api-key' | 'oidc' }\n\n/** Read per step: on Vercel the OIDC token rides on each function request. */\nexport function gatewayCredential(harness: string): GatewayCredential {\n  const key = process.env['AI_GATEWAY_API_KEY']\n  if (key) return { token: key, method: 'api-key' }\n  const oidc = requestOidcToken() ?? process.env['VERCEL_OIDC_TOKEN']\n  if (oidc) return { token: oidc, method: 'oidc' }\n  throw new Error(`${harness}() needs AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN`)\n}\n\n// Where Vercel Functions keep the current request, as @vercel/oidc reads it.\nconst REQUEST_CONTEXT = Symbol.for('@vercel/request-context')\n\nfunction requestOidcToken(): string | undefined {\n  const context = (\n    globalThis as {\n      [REQUEST_CONTEXT]?: { get?: () => { headers?: Record<string, unknown> } }\n    }\n  )[REQUEST_CONTEXT]\n  const token = context?.get?.()?.headers?.['x-vercel-oidc-token']\n  return typeof token === 'string' && token !== '' ? token : undefined\n}\n\n// ------------------------------------------------------------- helpers\n\nexport class Divergence extends Error {\n  constructor(harness: string, message: string) {\n    super(`${harness} replay diverged from the log: ${message}`)\n  }\n}\n\nexport type Deferred = { promise: Promise<void>; resolve: () => void }\n\nexport function deferred(): Deferred {\n  let resolve!: () => void\n  const promise = new Promise<void>((done) => {\n    resolve = done\n  })\n  return { promise, resolve }\n}\n\n/** A result that never settles; the harness is stopped instead. */\nexport function pending(\n  signal: AbortSignal | null | undefined,\n): Promise<never> {\n  return new Promise((_, reject) => {\n    if (signal?.aborted) reject(signal.reason)\n    signal?.addEventListener('abort', () => reject(signal.reason), {\n      once: true,\n    })\n  })\n}\n"],"mappings":"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"}

package/dist/ai-harness-CV6rXbB3.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai-harness-CV6rXbB3.d.ts","names":[],"sources":["../src/ai-harness.ts"],"mappings":";;;cAoBc;;;;;KAMF,QACV,wCACA;WAES,MAAM;YACL;aAA0B,OAAO;;;;KAIjC;EACV;aAAoB;;EACpB,QAAQ;;;KAIE,kBACV,SAAS,0BACN,8BAA8B,QAAQ"}