@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/tasks/extract-values.js

@@ -1,26 +1,20 @@
 /**
- * The extraction workflow on the profile rails, and the `ExtractionArm` realization over it.
+ * The extraction pass on the profile rails, and the `ExtractionArm` realization over it.
  *
  * The report resolver falls through to this arm for an over-cap file or a host parse fault. The arm runs one
  * fixed extraction script in an ephemeral sandbox, and it gives back the rows that the script read. No agent
  * loop runs anywhere in this path. A file whose extension names no tabular format never arrives here,
  * because the host decides the format and it refuses the file before the fall-through.
  *
- * The shape matches the data profile (`src/tasks/data-profile.ts`). The authorization mints at the async
- * edge (`triggerExtractValues`) and rides in the workflow input. The body never mints, and it revokes the
- * authorization on every terminal path. The container is ephemeral, and it goes away with the work, thus no
- * standing machine exists.
+ * The pass runs inside the step of the tool call that resolves the report (`sandbox/step-sandbox.ts`), under
+ * the auth of that call, and it mints no mandate. One call can run more than one pass, thus the exec of each
+ * pass takes the key of the step and a hash of its requests. The container is ephemeral, and it goes away
+ * with the work, thus no standing machine exists.
  */
-import { DBOS } from "@dbos-inc/dbos-sdk";
-import { err, ok } from "neverthrow";
-import { randomUUID } from "node:crypto";
-import { forStep } from "../auth/types.js";
+import { createHash } from "node:crypto";
 import { createNoopLogger } from "../lib/console-logger.js";
-import { deliverNotice, passGate } from "../lib/hooks.js";
-import { generateExecutionId } from "../sandbox/execution-id.js";
-import { mintSandboxIdentity } from "../sandbox/identity.js";
-import { keepSuspendingRefusal } from "../sandbox/sandbox-error.js";
-import { suspensionOfRefusal, suspensionOfSpawnRefusal } from "../workflows/suspension.js";
+import { safeParseJsonAs } from "../lib/parse-json.js";
+import { passSpawnSession, withStepSandbox } from "../sandbox/step-sandbox.js";
 import { EXTRACTION_INPUT_ENV, EXTRACTION_SCRIPT, ExtractValuesResultSchema } from "./extract-values-script.js";
 /** The synthetic run id and step id of the extraction pass. Both are constants shared by every analysis. */
 const EXTRACT_VALUES_RUN_LITERAL = "extract-values";
@@ -35,8 +29,6 @@ const EXTRACTION_DEADLINE_MS = 300_000;
  * carries no file size. A later change can size it from the batch.
  */
 const EXTRACTION_RESOURCES = { cpu: 2, memoryGb: 8 };
-/** The exec progress callback. The extraction pass reports no live activity, thus the callback drops each event. */
-const noopEmit = () => { };
 /**
  * Build the sandbox exec for one extraction pass. The command runs the fixed script through `python3 -c`.
  * The working directory is the analysis mount, thus a relative request path reads the correct file. The
@@ -51,20 +43,29 @@ const noopEmit = () => { };
  * The function is pure, thus a test asserts the command shape without a sandbox.
  */
 export function buildExtractionExec(analysisId, requests) {
-    const scriptRequests = requests.map((request) => ({ path: request.path, format: request.format, hash: request.hash }));
     return {
         command: ["python3", "-c", EXTRACTION_SCRIPT],
         cwd: `/${analysisId}`,
-        env: { [EXTRACTION_INPUT_ENV]: JSON.stringify(scriptRequests) },
+        env: { [EXTRACTION_INPUT_ENV]: JSON.stringify(scriptRequests(requests)) },
         timeoutSeconds: Math.floor(EXTRACTION_DEADLINE_MS / 1000),
     };
 }
+function scriptRequests(requests) {
+    return requests.map((request) => ({ path: request.path, format: request.format, hash: request.hash }));
+}
+/** The key of one pass inside its step: the same requests give the same exec, and other requests a new one. */
+function requestKey(requests) {
+    return createHash("sha256")
+        .update(JSON.stringify(scriptRequests(requests)), "utf8")
+        .digest("hex")
+        .slice(0, 16);
+}
 /**
  * Parse the script output from the exec result. A synthetic failure, a timeout, and a non-zero exit each
  * throw, because each means the script did not emit its map. A stdout that is not the map shape throws too.
  *
- * The function is pure, thus a test asserts the parse without a sandbox. The throw crosses the workflow
- * boundary, and the arm turns it into a rejected promise.
+ * The function is pure, thus a test asserts the parse without a sandbox. The arm turns the throw into a
+ * rejected promise.
  */
 export function parseExtractionOutput(result) {
     if (result.syntheticFailure !== undefined) {
@@ -78,104 +79,42 @@ export function parseExtractionOutput(result) {
     }
     let parsed;
     try {
-        parsed = JSON.parse(result.stdout);
+        parsed = safeParseJsonAs(result.stdout, ExtractValuesResultSchema);
     }
     catch {
         throw new Error("the extraction script did not emit valid JSON");
     }
-    return ExtractValuesResultSchema.parse(parsed);
+    if (!parsed.success)
+        throw parsed.error;
+    return parsed.data;
 }
 /**
- * The body, extracted so a test drives it without a registered workflow. It creates the ephemeral
- * container, submits one exec, awaits the result durably, and gives the value map back. It revokes the run
- * authorization on every terminal path, and it tears the container down on both paths.
+ * Run one extraction pass: make the container, run the script on every request, and remove the container.
  *
- * A chat turn awaits this workflow, thus a suspension is the `err` of the result, and the workflow does not
- * cancel (workflow-suspension spec). The body does not mark the analysis: the caller reports the suspension.
+ * A suspending refusal of the spawn is the `err`, and the caller reports it. Each other fault throws.
  */
-export async function runExtractValuesBody(input, deps) {
-    const logger = (deps.logger ?? createNoopLogger()).named("extract-values").with({ analysisId: input.analysisId });
-    const { analysisId, runSession, requests, ownsMandate = true } = input; // oss-core-managed-ok
-    const authorization = { runSession, ownsMandate }; // oss-core-managed-ok
-    const revoke = (reason) => deliverNotice(logger, "RunAuthorizer.revoke", deps.runAuthorizer.revoke(authorization, reason));
+export async function runExtraction(deps, caller, requests) {
+    const logger = (deps.logger ?? createNoopLogger()).named("extract-values").with({ analysisId: caller.analysisId });
     try {
-        const executionId = generateExecutionId(EXTRACT_VALUES_AGENT_ID);
-        const workflowId = DBOS.workflowID ?? `${EXTRACT_VALUES_RUN_LITERAL}:${executionId}`;
-        // The container mounts the analysis tree read-only. The extraction pass only reads, thus it needs
-        // no writable step mount.
-        const spawned = keepSuspendingRefusal(await deps.sandboxClient.createSandbox(forStep(runSession, EXTRACT_VALUES_STEP_LITERAL), { childWorkflowId: workflowId, resources: EXTRACTION_RESOURCES, readOnly: true }, mintSandboxIdentity(EXTRACT_VALUES_RUN_LITERAL)));
-        if (spawned.isErr()) {
-            const suspension = suspensionOfSpawnRefusal(spawned.error);
-            logger.warn("extraction suspended", { reason: suspension.reason });
-            await revoke("extract-values-suspended");
-            return err(suspension);
-        }
-        const sandbox = spawned.value;
-        try {
-            // A checkpointed clock, not `Date.now()`: a wall-clock deadline would grow on each recovery.
-            const deadlineAbs = (await DBOS.now()) + EXTRACTION_DEADLINE_MS;
-            const result = await deps.sandboxClient.exec(sandbox, buildExtractionExec(analysisId, requests), noopEmit, deadlineAbs);
-            const map = parseExtractionOutput(result);
-            await revoke("extract-values-completed");
-            return ok(map);
-        }
-        finally {
-            try {
-                await deps.sandboxClient.teardown(sandbox);
-            }
-            catch (teardownErr) {
-                logger.warn("teardown failed (non-fatal)", { executionId, ...logger.errorFields(teardownErr) });
-            }
-        }
-    }
-    catch (err) {
-        logger.error("extraction failed", logger.errorFields(err));
-        await revoke("extract-values-failed");
-        throw err;
+        const ran = await withStepSandbox(deps.sandboxClient, {
+            session: passSpawnSession(caller, {
+                analysisId: caller.analysisId,
+                runId: EXTRACT_VALUES_RUN_LITERAL,
+                stepId: EXTRACT_VALUES_STEP_LITERAL,
+                agentId: EXTRACT_VALUES_AGENT_ID,
+            }),
+            // The pass only reads, thus the container mounts the analysis tree read-only.
+            spec: { resources: EXTRACTION_RESOURCES, readOnly: true },
+            execKey: requestKey(requests),
+        }, logger, async (exec) => parseExtractionOutput(await exec(buildExtractionExec(caller.analysisId, requests), EXTRACTION_DEADLINE_MS)));
+        if (ran.isErr())
+            logger.warn("the host refused the sandbox of the extraction", { reason: ran.error.reason });
+        return ran;
     }
-}
-/**
- * Register the extraction workflow with DBOS. It gives back the registered callable, thus a trigger
- * dispatches with `DBOS.startWorkflow`.
- */
-export function registerExtractValuesWorkflow(deps) {
-    return DBOS.registerWorkflow((input) => runExtractValuesBody(input, deps), { name: "extract-values" });
-}
-/** The per-attempt workflow id. A fresh nonce keeps each pass under a distinct id. */
-export function extractValuesWorkflowId(analysisId, nonce) {
-    return `extract-values:${analysisId}:${nonce}`;
-}
-/**
- * The async edge. It authorizes through the `RunAuthorizer`, starts the workflow, and awaits the outcome.
- * The body owns the revoke, thus the trigger holds no lifecycle. A workflow fault and a refused
- * authorization reject the returned promise. A suspension is the `err` of the result: of the workflow, or of
- * an authorization that the host refused with the suspend flag.
- */
-export async function triggerExtractValues(deps, params) {
-    const { auth, analysisId, requests } = params;
-    const authorized = await passGate("RunAuthorizer.authorize", deps.runAuthorizer.authorize({
-        auth,
-        scope: { kind: "analysis", analysisId },
-        provenance: { agentId: EXTRACT_VALUES_AGENT_ID, callPath: [EXTRACT_VALUES_AGENT_ID] },
-        frame: { runId: EXTRACT_VALUES_RUN_LITERAL, stepId: EXTRACT_VALUES_STEP_LITERAL },
-    }));
-    if (authorized.isErr()) {
-        const suspension = suspensionOfRefusal(authorized.error);
-        if (suspension !== undefined)
-            return err(suspension);
-        throw new Error(`the extraction was not authorized: ${authorized.error.reason}`);
+    catch (cause) {
+        logger.error("extraction failed", logger.errorFields(cause));
+        throw cause;
     }
-    const { runSession, ownsMandate } = authorized.value; // oss-core-managed-ok
-    const handle = (await DBOS.startWorkflow(deps.workflow, {
-        workflowID: extractValuesWorkflowId(analysisId, randomUUID()),
-    })({ analysisId, runSession, requests: [...requests], ownsMandate })); // oss-core-managed-ok
-    return handle.getResult();
-}
-/**
- * Bind the trigger to one analysis and one auth context. The result runs one pass with every request in it.
- */
-export function bindExtractionTrigger(deps, binding) {
-    return (requests) => triggerExtractValues(deps, { auth: binding.auth, analysisId: binding.analysisId, requests });
 }
 /**
  * Turn the raw script output into the arm result. A path with rows enters the map. A path with an error
@@ -195,7 +134,8 @@ export function extractionArtifactsFromResult(result) {
 /**
  * Make the extraction arm over a runner. One `extract` call makes one run with every request in it, and it
  * gives the value map. A run fault rejects the promise, and the resolver turns the rejection into a failed
- * reference. A suspension is the `err`, and the resolver reports its reason on each reference.
+ * reference. A refusal of the sandbox with the suspend flag is the `err`, and the resolver reports its reason on each
+ * reference.
  */
 export function createExtractionArm(run) {
     return {

package/dist/tasks/refresh-regulatory-corpus.d.ts

@@ -12,11 +12,11 @@
 import type { Pool } from "pg";
 export type RegulatoryCorpusSource = "FDA-CDER" | "FDA-CBER" | "ICH";
 export declare const REGULATORY_CORPUS_SOURCES: RegulatoryCorpusSource[];
-export interface RefreshResult {
+export type RefreshResult = {
     ok: number;
     fail: number;
-}
-export interface RefreshOptions {
+};
+export type RefreshOptions = {
     pool: Pool;
     sources?: RegulatoryCorpusSource[];
     /**
@@ -30,23 +30,7 @@ export interface RefreshOptions {
     embedder: (text: string) => Promise<number[]>;
     /** Logger used for per-doc progress. Defaults to `console`. */
     log?: Pick<Console, "log" | "error">;
-}
-/**
- * Build an embedder that talks directly to api.openai.com using the given
- * `apiKey`, bypassing the billing gateway.
- *
- * Returns `null` when `apiKey` is missing — callers MUST treat that as
- * "auto-refresh disabled" rather than falling back to the workspace
- * embedder (`workspace/search-config.ts`), which routes through the billing gateway
- * via `OPENAI_BASE_URL` and would generate unbilled calls outside an ALS
- * billing scope.
- *
- * The model id mirrors the workspace embedder default
- * (`text-embedding-3-small`, 1536 dim) so chunks remain comparable to the
- * default `cortex_regulatory_chunks.embedding` shape. Pass the existing
- * `OPENAI_API_KEY` (a real OpenAI key, NOT a billing-gateway virtual key — direct
- * calls to api.openai.com would 401 against a `sk-billing-*` value).
- */
+};
 export declare function buildMaintenanceEmbedder(opts: {
     apiKey?: string;
     embeddingModel?: string;

package/dist/tasks/refresh-regulatory-corpus.js

@@ -9,10 +9,14 @@
  *   - `scripts/index-regulatory-corpus.ts` — operator-run CLI
  *   - `regulatory-corpus-boot-refresh.ts` — automatic 90-day-stale boot trigger
  */
+import { errorMessageOf } from "../lib/thrown.js";
+import { textOf } from "../lib/unknown-text.js";
 import { unwrapOrThrow } from "../lib/result.js";
+import { presentAt } from "../lib/present.js";
 import { fetchFdaGuidanceListing, fetchAndExtractFdaDoc } from "../lib/regulatory-corpus/fetch-fda-guidance.js";
 import { fetchIchListing, fetchAndExtractIchDoc } from "../lib/regulatory-corpus/fetch-ich.js";
 import { chunkText, upsertChunks } from "../lib/regulatory-corpus.js";
+import { z } from "zod";
 export const REGULATORY_CORPUS_SOURCES = ["FDA-CDER", "FDA-CBER", "ICH"];
 // A large guidance doc can chunk into 200-500+ pieces. Firing them all at
 // once trips embedding-API rate limits and silently truncates the upserted
@@ -34,6 +38,7 @@ const EMBED_CONCURRENCY = 20;
  * `OPENAI_API_KEY` (a real OpenAI key, NOT a billing-gateway virtual key — direct
  * calls to api.openai.com would 401 against a `sk-billing-*` value).
  */
+const EmbeddingResponseSchema = z.object({ data: z.array(z.object({ embedding: z.array(z.number()) })) });
 export function buildMaintenanceEmbedder(opts) {
     const { apiKey } = opts;
     if (!apiKey)
@@ -56,9 +61,9 @@ export function buildMaintenanceEmbedder(opts) {
             const body = await res.text();
             throw new Error(`buildMaintenanceEmbedder: openai /embeddings ${res.status}: ${body}`);
         }
-        const data = (await res.json());
-        const embedding = data.data?.[0]?.embedding;
-        if (!embedding)
+        const data = EmbeddingResponseSchema.parse(await res.json());
+        const embedding = data.data[0]?.embedding;
+        if (!embedding || embedding.length === 0)
             throw new Error("buildMaintenanceEmbedder: empty response");
         return embedding;
     };
@@ -79,10 +84,9 @@ async function listForSource(source) {
             return await fetchIchListing();
     }
 }
+// Each source's listing carries only its own stub kind, thus the stub's own shape picks the fetcher.
 async function fetchOne(source, stub) {
-    if (source === "ICH")
-        return await fetchAndExtractIchDoc(stub);
-    return await fetchAndExtractFdaDoc(stub);
+    return "center" in stub ? await fetchAndExtractFdaDoc(stub) : await fetchAndExtractIchDoc(stub);
 }
 async function indexSource(pool, source, embedder, log) {
     log.log(`\n=== ${source} ===`);
@@ -104,7 +108,7 @@ async function indexSource(pool, source, embedder, log) {
                 const batchResults = await Promise.all(batch.map((c) => embedder(c.text)));
                 embeddings.push(...batchResults);
             }
-            const chunks = rawChunks.map((c, i) => ({ ...c, embedding: embeddings[i] }));
+            const chunks = rawChunks.map((c, i) => ({ ...c, embedding: presentAt(embeddings, i, "the embedding of the chunk") }));
             const row = {
                 source,
                 doc_id: doc.doc_id,
@@ -119,7 +123,7 @@ async function indexSource(pool, source, embedder, log) {
         }
         catch (err) {
             fail++;
-            const msg = err instanceof Error ? err.message : String(err);
+            const msg = errorMessageOf(err) ?? textOf(err);
             log.error(`  FAIL ${stub.doc_id}: ${msg}`);
         }
     }

package/dist/tasks/regulatory-corpus-boot-refresh.d.ts

@@ -17,7 +17,7 @@
 import type { Pool } from "pg";
 import { refreshRegulatoryCorpus, type RefreshOptions } from "./refresh-regulatory-corpus.js";
 export declare const REFRESH_INTERVAL_DAYS = 90;
-export interface BootRefreshDeps {
+export type BootRefreshDeps = {
     /** Shared `pg.Pool`. */
     pool: Pool;
     /** Forwarded to `refreshRegulatoryCorpus()` when the refresh fires. */
@@ -39,7 +39,7 @@ export interface BootRefreshDeps {
     embeddingModel?: string;
     /** Direct OpenAI key for the maintenance embedder (NOT a billing-gateway VK). */
     openaiApiKey?: string;
-}
+};
 /**
  * Check the corpus freshness and, if stale, kick off an asynchronous
  * refresh. Resolves quickly — does NOT wait for the refresh to finish.

package/dist/tasks/regulatory-corpus-boot-refresh.js

@@ -14,16 +14,18 @@
  * but the cost of a redundant check is one round-trip; the actual scrape
  * is what we serialize.
  */
+import { errorMessageOf } from "../lib/thrown.js";
 import { buildMaintenanceEmbedder, refreshRegulatoryCorpus } from "./refresh-regulatory-corpus.js";
 export const REFRESH_INTERVAL_DAYS = 90;
 const ADVISORY_LOCK_KEY = "cortex_regulatory_corpus_refresh";
 async function checkFreshness(pool, intervalDays) {
+    // EXTRACT gives numeric, which node-pg returns as a string, thus the float8 cast makes `age_days` a number.
     const { rows } = await pool.query(`SELECT MAX(indexed_at) AS last_indexed_at,
-            EXTRACT(EPOCH FROM (NOW() - MAX(indexed_at))) / 86400 AS age_days
+            (EXTRACT(EPOCH FROM (NOW() - MAX(indexed_at))) / 86400)::float8 AS age_days
      FROM cortex_regulatory_chunks`);
     const row = rows[0];
     const lastIndexedAt = row?.last_indexed_at ?? null;
-    const ageDays = row?.age_days != null ? Number(row.age_days) : null;
+    const ageDays = row?.age_days != null ? row.age_days : null;
     const stale = lastIndexedAt === null || (ageDays ?? Infinity) >= intervalDays;
     return { stale, lastIndexedAt, ageDays };
 }
@@ -71,11 +73,11 @@ export async function maybeKickOffRegulatoryCorpusRefresh(deps) {
         freshness = await checkFreshness(pool, intervalDays);
     }
     catch (err) {
-        log.warn("[boot] Regulatory corpus freshness check failed; skipping auto-refresh:", err instanceof Error ? err.message : err);
+        log.warn("[boot] Regulatory corpus freshness check failed; skipping auto-refresh:", errorMessageOf(err) ?? err);
         return "error";
     }
     if (!freshness.stale) {
-        log.log(`[boot] Regulatory corpus is fresh (age ${freshness.ageDays?.toFixed(1)}d < ${intervalDays}d); skipping refresh`);
+        log.log(`[boot] Regulatory corpus is fresh (age ${String(freshness.ageDays?.toFixed(1))}d < ${intervalDays}d); skipping refresh`);
         return "skipped-fresh";
     }
     // Corpus is stale — resolve the maintenance embedder. System-scoped
@@ -92,12 +94,12 @@ export async function maybeKickOffRegulatoryCorpusRefresh(deps) {
             });
         }
         catch (err) {
-            log.warn("[boot] Could not load env for regulatory corpus refresh; skipping:", err instanceof Error ? err.message : err);
+            log.warn("[boot] Could not load env for regulatory corpus refresh; skipping:", errorMessageOf(err) ?? err);
             return "skipped-unconfigured";
         }
     }
     if (!embedder) {
-        const ageStr = freshness.lastIndexedAt === null ? "empty" : `age ${freshness.ageDays?.toFixed(1)}d`;
+        const ageStr = freshness.lastIndexedAt === null ? "empty" : `age ${String(freshness.ageDays?.toFixed(1))}d`;
         log.warn(`[boot] Regulatory corpus is stale (${ageStr}) but ` +
             "REGULATORY_CORPUS_OPENAI_API_KEY is unset; skipping auto-refresh. " +
             "Set it (a real OpenAI key, NOT a billing-gateway virtual key — the " +
@@ -116,7 +118,7 @@ export async function maybeKickOffRegulatoryCorpusRefresh(deps) {
     }
     catch (err) {
         client.release();
-        log.warn("[boot] Regulatory corpus advisory-lock attempt failed; skipping auto-refresh:", err instanceof Error ? err.message : err);
+        log.warn("[boot] Regulatory corpus advisory-lock attempt failed; skipping auto-refresh:", errorMessageOf(err) ?? err);
         return "error";
     }
     if (!acquired) {
@@ -124,21 +126,21 @@ export async function maybeKickOffRegulatoryCorpusRefresh(deps) {
         log.log("[boot] Regulatory corpus refresh already in progress on another replica; skipping");
         return "skipped-locked";
     }
-    const ageStr = freshness.lastIndexedAt === null ? "empty" : `age ${freshness.ageDays?.toFixed(1)}d`;
+    const ageStr = freshness.lastIndexedAt === null ? "empty" : `age ${String(freshness.ageDays?.toFixed(1))}d`;
     log.log(`[boot] Regulatory corpus is stale (${ageStr}); starting async refresh in background`);
     // Detached promise — startup must not wait for this to finish.
     const dispatchEmbedder = embedder;
     void (async () => {
         try {
             const result = await refresh({
-                ...(deps.refreshOptions ?? {}),
+                ...deps.refreshOptions,
                 pool,
                 embedder: dispatchEmbedder,
             });
             log.log(`[boot] Regulatory corpus refresh complete: ok=${result.ok} fail=${result.fail}`);
         }
         catch (err) {
-            log.error("[boot] Regulatory corpus refresh threw:", err instanceof Error ? err.message : err);
+            log.error("[boot] Regulatory corpus refresh threw:", errorMessageOf(err) ?? err);
         }
         finally {
             await releaseLock(client);

package/dist/testing.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The test kit of the harness: a scripted model for a test of an agent, a chat
+ * turn, or a tool that runs a sub-agent. It is a `ChatProvider` over the mock
+ * model of the AI SDK. Each request takes the next entry of the script, and the
+ * kit records each request that the model got. `inProcessChatTurns` gives the
+ * chat turns of a runtime with no DBOS engine, over the turn in process. An
+ * embedder imports it from `@inflexa-ai/harness/testing`.
+ */
+import type { LanguageModelV4CallOptions, SharedV4ProviderMetadata } from "@ai-sdk/provider";
+import type { ResolveRequestHeaders } from "./providers/request-headers.js";
+export { inProcessChatTurns } from "./app/in-process-turn.js";
+import type { ChatProvider, ChatUsage, ProviderCapabilities } from "./providers/types.js";
+export type ScriptedPart = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "reasoning";
+    readonly text: string;
+    readonly signature?: string;
+} | {
+    readonly type: "tool-call";
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly input: unknown;
+};
+export type ScriptedReply = {
+    readonly content: readonly ScriptedPart[];
+    readonly finishReason: "stop" | "tool-calls" | "length" | "content-filter" | "other" | "error";
+    readonly rawFinishReason?: string;
+    readonly usage?: ChatUsage;
+    readonly providerMetadata?: SharedV4ProviderMetadata;
+    readonly responseId?: string;
+    readonly modelId?: string;
+};
+/** A request that fails: the model throws the value when it opens its stream. */
+export type ScriptedFailure = {
+    readonly fail: unknown;
+};
+/** A reply that streams its first parts, and then fails with an error part. */
+export type ScriptedBreak = {
+    readonly breakAfter: readonly ScriptedPart[];
+    readonly error: unknown;
+};
+export type ScriptEntry = ScriptedReply | ScriptedFailure | ScriptedBreak;
+export type ScriptStep = ScriptEntry | ((call: LanguageModelV4CallOptions) => ScriptEntry | Promise<ScriptEntry>);
+export type ScriptedModel = {
+    readonly provider: ChatProvider;
+    /** Each request that the model got, in order. */
+    readonly calls: LanguageModelV4CallOptions[];
+};
+export declare function text(value: string): ScriptedPart;
+export declare function reasoning(value: string, signature?: string): ScriptedPart;
+export declare function toolCall(toolCallId: string, toolName: string, input: unknown): ScriptedPart;
+export declare function reply(content: readonly ScriptedPart[], finishReason?: ScriptedReply["finishReason"], usage?: ChatUsage): ScriptedReply;
+/** The reply of a round of tool calls. */
+export declare function callTools(...calls: readonly ScriptedPart[]): ScriptedReply;
+/** Build a provider over a scripted model. A request past the end of the script fails the test that made it. */
+export declare function scriptedModel(script: readonly ScriptStep[], options?: {
+    readonly capabilities?: Partial<ProviderCapabilities>;
+    readonly maxRetries?: number;
+    readonly resolveRequestHeaders?: ResolveRequestHeaders;
+}): ScriptedModel;

package/dist/testing.js

@@ -0,0 +1,101 @@
+/**
+ * The test kit of the harness: a scripted model for a test of an agent, a chat
+ * turn, or a tool that runs a sub-agent. It is a `ChatProvider` over the mock
+ * model of the AI SDK. Each request takes the next entry of the script, and the
+ * kit records each request that the model got. `inProcessChatTurns` gives the
+ * chat turns of a runtime with no DBOS engine, over the turn in process. An
+ * embedder imports it from `@inflexa-ai/harness/testing`.
+ */
+import { convertArrayToReadableStream, MockLanguageModelV4 } from "ai/test";
+import { createAiSdkProvider } from "./providers/ai-sdk.js";
+export { inProcessChatTurns } from "./app/in-process-turn.js";
+export function text(value) {
+    return { type: "text", text: value };
+}
+export function reasoning(value, signature) {
+    return signature === undefined ? { type: "reasoning", text: value } : { type: "reasoning", text: value, signature };
+}
+export function toolCall(toolCallId, toolName, input) {
+    return { type: "tool-call", toolCallId, toolName, input };
+}
+export function reply(content, finishReason = "stop", usage) {
+    return usage === undefined ? { content, finishReason } : { content, finishReason, usage };
+}
+/** The reply of a round of tool calls. */
+export function callTools(...calls) {
+    return { content: calls, finishReason: "tool-calls" };
+}
+function v4Usage(usage) {
+    return {
+        inputTokens: { total: usage?.inputTokens, noCache: undefined, cacheRead: usage?.cacheReadInputTokens, cacheWrite: usage?.cacheCreationInputTokens },
+        outputTokens: { total: usage?.outputTokens, text: undefined, reasoning: usage?.reasoningTokens },
+    };
+}
+function contentParts(content) {
+    const parts = [];
+    for (const [index, part] of content.entries()) {
+        const id = `p${index}`;
+        switch (part.type) {
+            case "text":
+                parts.push({ type: "text-start", id }, { type: "text-delta", id, delta: part.text }, { type: "text-end", id });
+                break;
+            case "reasoning": {
+                const providerMetadata = part.signature === undefined ? undefined : { anthropic: { signature: part.signature } };
+                parts.push({ type: "reasoning-start", id }, { type: "reasoning-delta", id, delta: part.text }, { type: "reasoning-end", id, providerMetadata });
+                break;
+            }
+            case "tool-call":
+                parts.push({ type: "tool-call", toolCallId: part.toolCallId, toolName: part.toolName, input: JSON.stringify(part.input) });
+                break;
+        }
+    }
+    return parts;
+}
+function streamOf(entry, index) {
+    return [
+        { type: "stream-start", warnings: [] },
+        { type: "response-metadata", id: entry.responseId ?? `response-${index}`, modelId: entry.modelId ?? "scripted-model", timestamp: new Date(0) },
+        ...contentParts(entry.content),
+        {
+            type: "finish",
+            finishReason: { unified: entry.finishReason, raw: entry.rawFinishReason ?? entry.finishReason },
+            usage: v4Usage(entry.usage),
+            providerMetadata: entry.providerMetadata,
+        },
+    ];
+}
+/** Build a provider over a scripted model. A request past the end of the script fails the test that made it. */
+export function scriptedModel(script, options = {}) {
+    const calls = [];
+    const model = new MockLanguageModelV4({
+        provider: "scripted",
+        modelId: "scripted-model",
+        doStream: async (call) => {
+            const index = calls.length;
+            calls.push(call);
+            const step = script[index];
+            if (step === undefined)
+                throw new Error(`the script has no reply ${index}`);
+            const entry = typeof step === "function" ? await step(call) : step;
+            if ("fail" in entry)
+                throw entry.fail;
+            if ("breakAfter" in entry) {
+                return {
+                    stream: convertArrayToReadableStream([
+                        { type: "stream-start", warnings: [] },
+                        ...contentParts(entry.breakAfter),
+                        { type: "error", error: entry.error },
+                    ]),
+                };
+            }
+            return { stream: convertArrayToReadableStream(streamOf(entry, index)) };
+        },
+    });
+    const provider = createAiSdkProvider({
+        model,
+        capabilities: options.capabilities,
+        maxRetries: options.maxRetries ?? 0,
+        resolveRequestHeaders: options.resolveRequestHeaders,
+    });
+    return { provider, calls };
+}

package/dist/tools/ad-hoc-router.d.ts

@@ -1,9 +1,9 @@
-import type { Pool } from "pg";
+import type { Querier } from "../state/db.js";
 import { type AgentSession } from "../auth/types.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { ResourcePolicy, ResourceSpec } from "../config/resource-limits.js";
 import type { Logger } from "../lib/logger.js";
-import { type AgentRunUsage } from "../loop/metrics.js";
+import type { AgentRunUsage } from "../loop/metrics.js";
 import { type ChatProvider } from "../providers/types.js";
 import type { CheckedPackage } from "./sandbox/list-available-packages.js";
 export declare const AD_HOC_ROUTER_AGENT_ID = "adhoc-router";
@@ -16,11 +16,11 @@ export declare const AD_HOC_FALLBACK_AGENT_ID = "scientific-executor";
  * - `absent` — the bound resolution answered that the pool holds no such
  *   package, and it offered no other spelling.
  */
-export interface DroppedPackage {
+export type DroppedPackage = {
     readonly entry: string;
     readonly reason: "unparsable" | "absent";
-}
-export interface AdHocRoute {
+};
+export type AdHocRoute = {
     readonly agentId: string;
     readonly resources: ResourceSpec;
     readonly rationale: string;
@@ -31,11 +31,11 @@ export interface AdHocRoute {
     /** Every entry that the validation removed, with the reason for the caveat. */
     readonly droppedPackages: readonly DroppedPackage[];
     readonly fallbackClass?: "timeout" | "provider_error" | "malformed" | "no_match" | "invalid_agent" | "invalid_resources";
-}
-export interface AdHocRouterDeps {
+};
+export type AdHocRouterDeps = {
     readonly provider: ChatProvider;
     readonly model: string;
-    readonly pool: Pool;
+    readonly pool: Querier;
     readonly resourcePolicy?: ResourcePolicy;
     readonly logger?: Logger;
     /**
@@ -54,7 +54,7 @@ export interface AdHocRouterDeps {
     readonly resolvePackages?: (names: readonly string[]) => Promise<readonly CheckedPackage[] | null>;
     /** Falls back to the no-op recorder when omitted. */
     readonly usageRecorder?: UsageRecorder;
-}
+};
 export declare function defaultAdHocResources(policy?: ResourcePolicy): ResourceSpec;
 export declare function validAdHocResources(value: unknown, policy?: ResourcePolicy): ResourceSpec | null;
 export declare function routeAdHocRequest(deps: AdHocRouterDeps, input: {