experimental-a2 0.19.0 → 0.20.0

package/src/internal.ts

@@ -7,7 +7,8 @@ import type { ScheduledEvent } from './scheduler-task.ts'
 import type { DrainableServer } from './server.ts'
 import type { Event } from './store.ts'
 
-export type DrainOutcome = 'busy' | 'stalled' | 'settled'
+/** `failed`: a scheduler drain threw after arming its successor. */
+export type DrainOutcome = 'busy' | 'stalled' | 'settled' | 'failed'
 
 /**
  * A null-prototype record for maps keyed by caller-controlled strings

package/src/postgres-notifications.ts

@@ -220,25 +220,3 @@ export function postgresNotifications(
   }
   return manager
 }
-
-export const POSTGRES_NOTIFICATIONS_SQL = `
-create or replace function a2_notify_events() returns trigger language plpgsql as $$
-begin
-  perform pg_notify('a2_events_' || md5(new.session_id), '');
-  return null;
-end $$;
-create or replace function a2_notify_presence() returns trigger language plpgsql as $$
-begin
-  perform pg_notify('a2_presence_' || md5(case when TG_OP = 'DELETE' then old.ns else new.ns end),
-    coalesce(current_setting('a2.presence_source', true), ''));
-  return null;
-end $$;
-do $$ begin
-  if not exists (select 1 from pg_trigger where tgname = 'a2_notify_events' and tgrelid = 'a2_events'::regclass) then
-    create trigger a2_notify_events after insert on a2_events for each row execute function a2_notify_events();
-  end if;
-  if not exists (select 1 from pg_trigger where tgname = 'a2_notify_presence' and tgrelid = 'a2_presence'::regclass) then
-    create trigger a2_notify_presence after insert or update or delete on a2_presence for each row execute function a2_notify_presence();
-  end if;
-end $$;
-`

package/src/postgres-resources.ts

@@ -15,10 +15,7 @@ export type PostgresQueries = {
   client: PostgresClient
   raw: PostgresClient
   exclusive<T>(fn: () => Promise<T>): Promise<T>
-  initialize(options: {
-    schema: string
-    run: () => Promise<void>
-  }): Promise<void>
+  initialize(options: { key: string; run: () => Promise<void> }): Promise<void>
   close(): Promise<void>
 }
 
@@ -128,7 +125,7 @@ export function postgresConnectionKey({
 
 const queries = (raw: PostgresClient): PostgresQueries => {
   let pending: Promise<unknown> = Promise.resolve()
-  const schemas = new Map<string, Promise<void>>()
+  const initialized = new Map<string, Promise<void>>()
   const exclusive = <T>(fn: () => Promise<T>): Promise<T> => {
     const result = pending.then(fn)
     pending = result.catch(() => {})
@@ -140,13 +137,13 @@ const queries = (raw: PostgresClient): PostgresQueries => {
       ? raw
       : { query: (text, values) => exclusive(() => raw.query(text, values)) },
     exclusive,
-    initialize({ schema, run }) {
-      const existing = schemas.get(schema)
+    initialize({ key, run }) {
+      const existing = initialized.get(key)
       if (existing) return existing
       const attempt = run()
-      schemas.set(schema, attempt)
+      initialized.set(key, attempt)
       void attempt.catch(() => {
-        if (schemas.get(schema) === attempt) schemas.delete(schema)
+        if (initialized.get(key) === attempt) initialized.delete(key)
       })
       return attempt
     },

package/src/postgres-schema.ts

@@ -0,0 +1,80 @@
+/**
+ * The Postgres schema contract. A2 never runs DDL in a Postgres database:
+ * `sql/postgres/schema.sql` (and `notifications.sql` for
+ * `listenConnectionString`) create the tables, and a store checks the
+ * recorded version before its first query.
+ */
+
+import { A2Error } from './errors.ts'
+import type { PostgresClient } from './store-postgres.ts'
+
+/** The `a2_schema` version this release needs; `schema.sql` records it. */
+export const POSTGRES_SCHEMA_VERSION = 1
+
+const PACKAGE = 'node_modules/experimental-a2'
+
+const apply = (file: string): string =>
+  `apply ${PACKAGE}/sql/postgres/${file} to this database`
+
+const SEE_DOCS = `See ${PACKAGE}/docs/stores/04-postgres.mdx.`
+
+const VERSION = 'select version from a2_schema'
+const VERSION_AND_TRIGGERS = `select version, (select count(*) from pg_trigger
+   where (tgname = 'a2_notify_events' and tgrelid = to_regclass('a2_events'))
+      or (tgname = 'a2_notify_presence' and tgrelid = to_regclass('a2_presence')))
+  as notify_triggers from a2_schema`
+
+/** Explains a failed version read, or returns undefined when the schema is not the cause. */
+const diagnose = async (
+  client: PostgresClient,
+): Promise<A2Error | undefined> => {
+  const [found] = (
+    await client.query(`select
+      to_regclass('a2_schema') is not null as marked,
+      to_regclass('a2_events') is not null as installed,
+      has_table_privilege(to_regclass('a2_schema'), 'select') as readable`)
+  ).rows
+  if (!found) return undefined
+  if (!found['marked'])
+    return new A2Error(
+      'STORE_NOT_CONFIGURED',
+      found['installed']
+        ? `This Postgres database has A2's tables but no a2_schema version. That is expected once after upgrading from a release that created its tables at runtime, and your events are untouched. A2 doesn't create or change tables at runtime: ${apply('schema.sql')}. ${SEE_DOCS}`
+        : `A2's tables aren't in this Postgres database, and A2 doesn't create tables at runtime: ${apply('schema.sql')}. ${SEE_DOCS}`,
+    )
+  if (found['readable'] === false)
+    return new A2Error(
+      'STORE_NOT_CONFIGURED',
+      `The role this store connects as can't read a2_schema. Apply schema.sql as that role, or grant it select on a2_schema and select, insert, update, and delete on A2's other tables. ${SEE_DOCS}`,
+    )
+  return undefined
+}
+
+/** Reads the schema version (and, with a listener, the triggers) in one query that takes no lock a writer holds. */
+export const checkPostgresSchema = async ({
+  client,
+  listen,
+}: {
+  client: PostgresClient
+  listen: boolean
+}): Promise<void> => {
+  let row: Record<string, unknown> | undefined
+  try {
+    row = (await client.query(listen ? VERSION_AND_TRIGGERS : VERSION)).rows[0]
+  } catch (err) {
+    throw (await diagnose(client).catch(() => undefined)) ?? err
+  }
+  const version = Number(row?.['version'] ?? 0)
+  if (version < POSTGRES_SCHEMA_VERSION) {
+    throw new A2Error(
+      'STORE_NOT_CONFIGURED',
+      `This Postgres database has A2 schema version ${version}, and this release of experimental-a2 needs version ${POSTGRES_SCHEMA_VERSION}: ${apply('schema.sql')}. ${SEE_DOCS}`,
+    )
+  }
+  if (listen && Number(row?.['notify_triggers']) < 2) {
+    throw new A2Error(
+      'STORE_NOT_CONFIGURED',
+      `listenConnectionString needs A2's notification triggers, which aren't in this Postgres database. After schema.sql, ${apply('notifications.sql')}. ${SEE_DOCS}`,
+    )
+  }
+}

package/src/scheduler-qstash.ts

@@ -497,8 +497,11 @@ const readBoundedBody = async (
   return new TextDecoder().decode(bytes)
 }
 
-const storeUnavailable = (error: unknown): error is A2Error =>
-  error instanceof A2Error && error.code === 'STORE_UNAVAILABLE'
+// A store that isn't set up yet (Postgres before schema.sql, a missing driver)
+// is fixed without changing the task, so its work waits like any outage.
+const storeOutage = (error: unknown): error is A2Error =>
+  error instanceof A2Error &&
+  (error.code === 'STORE_UNAVAILABLE' || error.code === 'STORE_NOT_CONFIGURED')
 
 const response = {
   ok: (): Response => new Response('ok'),
@@ -888,7 +891,7 @@ export function qstash(options: QStashSchedulerOptions = {}): A2Scheduler {
               await deliverSchedulerAppend(server, task)
             else await deliverSchedulerClear(server, task)
           } catch (error) {
-            if (!storeUnavailable(error)) throw error
+            if (!storeOutage(error)) throw error
             await sendStoreOutageSuccessor(task, outage)
           }
           return response.ok()
@@ -906,13 +909,17 @@ export function qstash(options: QStashSchedulerOptions = {}): A2Scheduler {
                 outcome: 'unknown' as const,
               }
         } catch (error) {
-          if (!storeUnavailable(error)) throw error
+          if (!storeOutage(error)) throw error
           await sendStoreOutageSuccessor(task, outage)
           return response.ok()
         }
         if (result.settled) return response.ok()
 
-        if (result.outcome === 'busy' || result.outcome === 'stalled') {
+        if (
+          result.outcome === 'busy' ||
+          result.outcome === 'stalled' ||
+          result.outcome === 'failed'
+        ) {
           if (result.schedulerArm) await result.schedulerArm
           else {
             await sendTask({

package/src/scheduler-vercel.ts

@@ -14,7 +14,8 @@
  *   the configured deployment scope for sending and receiving.
  * - `handler(...servers)` is the delivery route: look up the server for
  *   the contract named in the message and drain it. Settled drains ack;
- *   contention and handler failure arm a later watchdog before acking.
+ *   contention, handler failure, and a drain that throws after arming its
+ *   successor all ack once a later watchdog is durable.
  *
  * `@vercel/queue` is an optional peer dependency, imported lazily. The
  * `transport` option is the injection seam — tests run a real little
@@ -342,9 +343,14 @@ export function vercelQueues(options: VercelQueuesOptions = {}): A2Scheduler {
               }
           if (result.settled) return
 
-          if (result.outcome === 'busy' || result.outcome === 'stalled') {
-            // The live owner arms its own claim windows, and the store holds
-            // a failed event until its retry time. Ensure a later slot here
+          if (
+            result.outcome === 'busy' ||
+            result.outcome === 'stalled' ||
+            result.outcome === 'failed'
+          ) {
+            // The live owner arms its own claim windows, the store holds
+            // a failed event until its retry time, and a drain that failed
+            // after claiming armed its successor. Ensure a later slot here
             // as well before relinquishing this durable delivery. If the queue is down, the
             // throw leaves the current message unacked for visibility-timeout
             // redelivery.

package/src/server.ts

@@ -50,6 +50,7 @@ import {
 } from './stream-buffer.ts'
 import type {
   A2Store,
+  CompleteAttemptResult,
   AppendEvent,
   Event,
   EventCause,
@@ -1004,7 +1005,7 @@ export function createServer<
     const signal = createDrainSignal()
     const p = new Promise<void>((resolve) => {
       queueMicrotask(() => {
-        void drainSession(sessionId, watchdogDueAt, signal)
+        void drainSession(sessionId, { watchdogDueAt, signal })
           .then(() => resolve())
           .catch(() => resolve())
       })
@@ -2931,8 +2932,16 @@ export function createServer<
 
   const drainSession = (
     sessionId: string,
-    watchdogDueAt?: number,
-    signal?: DrainSignal,
+    {
+      watchdogDueAt,
+      signal,
+      handOffFailure = false,
+    }: {
+      watchdogDueAt?: number | undefined
+      signal?: DrainSignal | undefined
+      /** Return a failure after arming as `failed` instead of throwing it. */
+      handOffFailure?: boolean
+    } = {},
   ): Promise<DrainResult> =>
     telemetry.span(
       'a2.drain',
@@ -3131,7 +3140,8 @@ export function createServer<
                   }
                 | undefined
               let handlerSignal = supersedeSignal
-              let returned: ReturnedEvent[]
+              let completion: CompleteAttemptResult
+              let completing = false
               try {
                 if (registration?.abortOn) {
                   subscription = await subscribeAbort(
@@ -3158,7 +3168,32 @@ export function createServer<
                   await subscription.close()
                   subscription = undefined
                 }
-                returned = await returnedEvents(sessionId, event, result)
+                const returned = await returnedEvents(sessionId, event, result)
+                await renewal
+                completing = true
+                completion = await telemetry.span(
+                  'a2.commit',
+                  {
+                    'a2.contract': name,
+                    'a2.session_id': sessionId,
+                    'a2.commit.operation': 'complete',
+                    'a2.commit.index': event.index,
+                    'a2.commit.attempt': event.attemptCount,
+                  },
+                  async (commitSpan) => {
+                    const committed = await store.completeAttempt({
+                      sessionId: ns,
+                      index: event.index,
+                      attempt: event.attemptCount,
+                      events: returned,
+                    })
+                    commitSpan.setAttribute(
+                      'a2.commit.outcome',
+                      committed.outcome,
+                    )
+                    return committed
+                  },
+                )
               } catch (err) {
                 if (supersedeSignal.aborted && err === supersedeSignal.reason) {
                   // The handler surrendered to its own abort — identity, not
@@ -3172,6 +3207,14 @@ export function createServer<
                     appendsEvents: false,
                   }
                 }
+                const refused =
+                  completing &&
+                  err instanceof A2Error &&
+                  err.code === 'PARTIAL_DUPLICATE_BATCH'
+                // A store that cannot record the completion is not the
+                // handler failing: the claim lapses, and the claim that takes
+                // it over counts it. A returned batch it refuses is.
+                if (completing && !refused) throw err
                 // Everything else — including a store fence rejection — is
                 // adjudicated by failAttempt, which is itself fenced: a
                 // genuinely superseded attempt gets 'superseded' back with
@@ -3192,11 +3235,14 @@ export function createServer<
                       index: event.index,
                       attempt: event.attemptCount,
                       error: describeError(err),
-                      // A NonRetriableError is terminal on its first throw:
-                      // deterministic failures should not burn the retry
-                      // budget before dead-lettering.
+                      // A NonRetriableError is terminal on its first throw,
+                      // and so is a refused batch, whose retry returns the
+                      // same ids: deterministic failures should not burn the
+                      // retry budget before dead-lettering.
                       maxFailures:
-                        err instanceof NonRetriableError ? 1 : MAX_FAILURES,
+                        err instanceof NonRetriableError || refused
+                          ? 1
+                          : MAX_FAILURES,
                       retryAfterMs: failureRetryDelayMs(event.failureCount + 1),
                     })
                     commitSpan.setAttribute('a2.commit.outcome', result.outcome)
@@ -3212,27 +3258,6 @@ export function createServer<
               } finally {
                 await subscription?.close()
               }
-              await renewal
-              const completion = await telemetry.span(
-                'a2.commit',
-                {
-                  'a2.contract': name,
-                  'a2.session_id': sessionId,
-                  'a2.commit.operation': 'complete',
-                  'a2.commit.index': event.index,
-                  'a2.commit.attempt': event.attemptCount,
-                },
-                async (commitSpan) => {
-                  const result = await store.completeAttempt({
-                    sessionId: ns,
-                    index: event.index,
-                    attempt: event.attemptCount,
-                    events: returned,
-                  })
-                  commitSpan.setAttribute('a2.commit.outcome', result.outcome)
-                  return result
-                },
-              )
               eventSpan.setAttribute(
                 'a2.event.outcome',
                 completion.outcome === 'completed'
@@ -3252,7 +3277,7 @@ export function createServer<
               return {
                 status: 'processed',
                 opensLane: event.lane !== null,
-                appendsEvents: returned.length > 0,
+                appendsEvents: completion.events.length > 0,
               }
             },
           )
@@ -3424,6 +3449,12 @@ export function createServer<
             if (signal) signal.closed = true
             break
           }
+        } catch (error) {
+          // The successor armed for this drain's claims drains the session
+          // again, so the scheduler delivery need not stay as a second retry.
+          if (!handOffFailure || schedulerArm === undefined) throw error
+          span.recordError(error)
+          outcome = 'failed'
         } finally {
           if (signal) signal.closed = true
           stopRenewing = true
@@ -3525,7 +3556,10 @@ export function createServer<
     },
     schedulerDrain: (sessionId, opts) => {
       assertSessionId(sessionId)
-      return drainSession(sessionId, opts?.watchdogDueAt)
+      return drainSession(sessionId, {
+        watchdogDueAt: opts?.watchdogDueAt,
+        handOffFailure: true,
+      })
     },
     schedulerAppend: async (sessionId, events, originIndex) => {
       if (!scheduler) {

package/src/store-postgres.ts

@@ -27,9 +27,9 @@ import { pollPresence } from './store-presence-polling.ts'
 import {
   postgresNotifications,
   postgresNotificationChannel,
-  POSTGRES_NOTIFICATIONS_SQL,
   type PostgresListenerConnection,
 } from './postgres-notifications.ts'
+import { checkPostgresSchema } from './postgres-schema.ts'
 import { retryableLazy } from './retryable-lazy.ts'
 import { postgresNotificationScope } from './postgres-notification-scope.ts'
 import { postgresPoolClient } from './postgres-pool.ts'
@@ -92,91 +92,6 @@ export type PostgresStore = A2Store & {
   close(): Promise<void>
 }
 
-const SCHEMA = `
-create table if not exists a2_events (
-  session_id   text    not null,
-  idx          bigint  not null,
-  event_type   text    not null,
-  payload      jsonb   not null,
-  event_id     text    not null,
-  created_at   bigint  not null,
-  cause        jsonb,
-  lane         text,
-  lane_ready   boolean not null default false,
-  processed_at bigint,
-  processed_by_attempt integer,
-  returned_event_ids jsonb,
-  first_claimed_at bigint,
-  last_claimed_at bigint,
-  attempt_count integer not null default 0,
-  failure_count integer not null default 0,
-  last_failed_at bigint,
-  last_failed_attempt integer,
-  last_error   text,
-  failed_at    bigint,
-  claim_holder text,
-  claim_expires_at bigint,
-  primary key (session_id, idx)
-);
-
-create unique index if not exists a2_events_event_id on a2_events (event_id);
-create index if not exists a2_events_unprocessed
-  on a2_events (session_id, idx) where processed_at is null;
-create index if not exists a2_events_lane_pending
-  on a2_events (session_id, lane, idx) where processed_at is null;
-create index if not exists a2_events_dispatch_ready
-  on a2_events (session_id, idx)
-  where lane_ready and processed_at is null and failed_at is null;
-create index if not exists a2_events_claim_expiry
-  on a2_events (session_id, claim_expires_at)
-  where lane_ready and processed_at is null and failed_at is null;
-
-create table if not exists a2_snapshots (
-  session_id   text   not null,
-  reducer_name text   not null,
-  up_to_index  bigint not null,
-  state        jsonb  not null,
-  updated_at   bigint not null,
-  primary key (session_id, reducer_name)
-);
-
-create table if not exists a2_snapshot_history (
-  session_id   text   not null,
-  reducer_name text   not null,
-  up_to_index  bigint not null,
-  state        jsonb  not null,
-  updated_at   bigint not null,
-  primary key (session_id, reducer_name, up_to_index)
-);
-
-create table if not exists a2_snapshot_pins (
-  session_id   text   not null,
-  event_index  bigint not null,
-  reducer_name text   not null,
-  up_to_index  bigint not null,
-  primary key (session_id, event_index, reducer_name, up_to_index)
-);
-
-create index if not exists a2_snapshot_pins_checkpoint
-  on a2_snapshot_pins (session_id, reducer_name, up_to_index);
-
-create table if not exists a2_clears (
-  session_id  text   primary key,
-  clear_index bigint not null
-);
-
-create table if not exists a2_presence (
-  ns          text   not null,
-  participant text   not null,
-  field       text   not null,
-  value       jsonb  not null,
-  seen        bigint not null,
-  at          bigint not null,
-  expires_at  bigint not null,
-  primary key (ns, participant, field)
-);
-`
-
 const asNumber = (value: unknown): number => Number(value) // bigint columns arrive as strings
 
 /**
@@ -281,37 +196,6 @@ const wrap = async <T>(fn: () => Promise<T>): Promise<T> => {
 
 const jsonb = (value: unknown): string => JSON.stringify(value) ?? 'null'
 
-const initializeSchema = async ({
-  client,
-  listen,
-}: {
-  client: PostgresClient
-  listen: boolean
-}): Promise<void> => {
-  const schema = SCHEMA + (listen ? POSTGRES_NOTIFICATIONS_SQL : '')
-  if (!client.connect) {
-    await client.query(schema)
-    return
-  }
-
-  const conn = await client.connect()
-  try {
-    await conn.query('begin')
-    // `if not exists` does not serialize concurrent catalog writes. Every
-    // serverless isolate takes the same transaction-scoped lock before DDL.
-    await conn.query(
-      "select pg_advisory_xact_lock(hashtext('a2:postgres:schema'))",
-    )
-    await conn.query(schema)
-    await conn.query('commit')
-  } catch (err) {
-    await conn.query('rollback').catch(() => {})
-    throw err
-  } finally {
-    conn.release()
-  }
-}
-
 const loadPg = async () =>
   import('pg').catch(() => {
     throw new A2Error(
@@ -420,12 +304,10 @@ export function postgres(options: PostgresStoreOptions = {}): PostgresStore {
     try {
       const listen = Boolean(options.listenConnectionString)
       const resource = lease.value
-      if (injected) await initializeSchema({ client: resource.client, listen })
-      else
-        await resource.initialize({
-          schema: SCHEMA + (listen ? POSTGRES_NOTIFICATIONS_SQL : ''),
-          run: () => initializeSchema({ client: resource.client, listen }),
-        })
+      await resource.initialize({
+        key: listen ? 'schema+triggers' : 'schema',
+        run: () => checkPostgresSchema({ client: resource.client, listen }),
+      })
       return lease
     } catch (error) {
       if (!injected) await lease.release().catch(() => {})

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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"}