@inflexa-ai/harness 0.19.0 → 0.19.2

package/dist/memory/ai-sdk-message-storage.js

@@ -73,8 +73,9 @@ export function isInterruptedMessage(message) {
     return message.providerOptions?.[HARNESS_PROVIDER_NAMESPACE]?.[INTERRUPTED_MESSAGE_KEY] === true;
 }
 /**
- * Build a `user` message the LOOP synthesized rather than a human typing it — today, the nudge that
- * continues a reply the model truncated at its output-token limit.
+ * Build a `user` message the LOOP synthesized rather than a human typing it — the nudge that
+ * continues a reply the model truncated at its output-token limit, and the message that carries a
+ * tool picture that the tool result cannot carry.
  *
  * It has to carry the `user` role because the wire format requires a user turn after a truncated
  * assistant message, but it is not user input, and the difference is load-bearing: a `user` message is
@@ -82,14 +83,18 @@ export function isInterruptedMessage(message) {
  * splitting one turn into two for the token window and, worse, giving a tail-turn removal a cut point in
  * the middle of a turn. Marking it is what lets {@link isSyntheticUserMessage} keep those readers honest.
  *
+ * `content` takes prose or the parts of a user message, because a picture rides a file part and no
+ * string can carry one. The marker is the same either way: what makes a message synthetic is who wrote
+ * it, not what it holds.
+ *
  * This one is loop MACHINERY and is not rendered: showing it would put words on screen nobody typed.
  * An embedder recording out-of-band work — an analysis run's outcome — wants
  * {@link syntheticRecordMessage} instead, which is equally non-turn-opening but IS displayed.
  */
-export function syntheticUserMessage(text) {
+export function syntheticUserMessage(content) {
     return {
         role: "user",
-        content: text,
+        content,
         providerOptions: { [HARNESS_PROVIDER_NAMESPACE]: { [SYNTHETIC_MESSAGE_KEY]: true } },
     };
 }

package/dist/memory/count-tokens.js

@@ -17,10 +17,39 @@ function enc() {
     return encoder;
 }
 /**
- * The token-bearing text of one content block. Text-carrying fields are
- * extracted directly; structural blocks (`tool_use` input, `tool_result`
- * payload) are JSON-stringified. A signed `thinking` block counts only its
- * reasoning text — the opaque `signature` is metadata, not prompt tokens.
+ * The token-bearing text of one tool-result output.
+ *
+ * A `content` output holds the text parts and the attachments side by side. Only
+ * the text is prompt text. A file rides the wire as an attachment, and the
+ * provider bills it at its own rate, thus its bytes count as `0` — the same rule
+ * as a top-level `file` block. A file that is stringified into the count inflates
+ * the row of the message by tens of thousands of tokens, and the load window then
+ * drops the true history.
+ *
+ * Each other output arm is plain JSON, thus it is stringified whole.
+ */
+function toolResultText(output) {
+    if (typeof output !== "object" || output === null)
+        return JSON.stringify(output ?? {});
+    const out = output;
+    if (out.type !== "content" || !Array.isArray(out.value))
+        return JSON.stringify(out);
+    const texts = [];
+    for (const item of out.value) {
+        if (typeof item !== "object" || item === null)
+            continue;
+        const nested = item;
+        if (nested.type === "text" && typeof nested.text === "string")
+            texts.push(nested.text);
+    }
+    return texts.join(" ");
+}
+/**
+ * The token-bearing text of one content block. A text-carrying field is
+ * extracted directly. A `tool_use` input is JSON-stringified, and a
+ * `tool_result` output goes through {@link toolResultText}. A signed `thinking`
+ * block counts only its reasoning text, because the opaque `signature` is
+ * metadata and not prompt tokens.
  */
 function tokenizableText(block) {
     if (typeof block === "string")
@@ -40,7 +69,7 @@ function tokenizableText(block) {
         case "tool-call":
             return `${String(part.toolName ?? "")} ${JSON.stringify(part.input ?? {})}`;
         case "tool-result": {
-            return `${String(part.toolName ?? "")} ${JSON.stringify(part.output ?? {})}`;
+            return `${String(part.toolName ?? "")} ${toolResultText(part.output)}`;
         }
         default:
             return JSON.stringify(part);

package/dist/prompts/report-session.d.ts

@@ -1 +1 @@
-export declare const reportSessionPrompt = "# Report Builder\n\nYou compose a scientific report for the user, one block at a time, and you ground\nevery claim in the analysis. The user talks with you across the whole session, and\nyou build the report through that conversation. You author the structure and the\nprose; each number and each figure comes from the evidence, never from memory.\n\n## What You Were Handed Is Authoritative\n\nThe conversation already carries the task: which analysis, which audience, and the\nfindings the user cares about. Start from what is in front of you. Reach for a read\ntool only where the context is thin, and reach in a targeted way:\n\n- `inspect_data_profile` \u2014 what the dataset is: its design, its organism, its\n  per-file types. Read it when you must state a fact about the data itself.\n- `inspect_run` \u2014 what a run produced, and where its outputs are. Read it when you\n  must ground a claim in a run's results.\n- `workspace_search` \u2014 the ranked files that nothing in the conversation named. It\n  gives descriptions and metadata, not contents.\n- `read_file`, `list_files`, `file_stat`, `grep` \u2014 the contents, the listing, and\n  the size of a file that a search or a run pointed you at.\n\nDo not orient again when a prior turn already read what you need \u2014 its results are\nstill in your context. To reach further is targeted, not a fresh sweep.\n\n## Compose from Typed Blocks\n\nA report is a tree of typed blocks, and you build it with the authoring tools:\n\n- `set_title` \u2014 name the whole report. A draft starts with none, and it needs one.\n- `add_block` \u2014 add one section, or one atom inside a section. You choose the id,\n  and it is unique in the draft. A section holds atoms. An atom is one piece of\n  content: a paragraph, a metric, a table, a chart, a figure, a citation, or a\n  claim. The block schema of `add_block` gives every kind and its fields.\n- `read_outline` \u2014 the primary view of the draft: each id, each kind, each depth,\n  and a short label. Read the outline, not the whole draft, to see where you are.\n- `read_block` \u2014 one block in full, when its outline label is not enough.\n\nBuild the report as a shape first, then fill each section. Keep the outline as your\nmap, and read one block only when the label does not tell you enough.\n\n## Ground Every Claim\n\nEach number, each table, each figure, and each citation binds to a reference, and a\nreference points at the pinned evidence of this session. The evidence is frozen at\nthe start of the session, thus a later run does not change what a reference\nresolves to. Bind every value. Never transcribe a number that you remember.\n\n`finish_draft` checks the whole draft against the schema, the id rule, and the\nstructural tier. It returns each completeness gap, or the finished document. Read\nthe gaps, repair the draft, and finish again.\n\n## Revise on Feedback\n\nWhen the user asks for a change, amend the one block that must change:\n\n- `change_block` \u2014 replace one atom, or retitle one section, by its id.\n- `move_block` \u2014 move one block to a new place by its id.\n- `remove_block` \u2014 remove one block, and its subtree, by its id.\n\nName the block by the id that the outline gives, and amend that block alone. Do not\nrebuild the report to make one change.\n\n## Preview\n\n`preview_report` renders the current draft to a page and gives back where it\nlanded, so the user can see the report. It finishes the draft first: an incomplete\ndraft comes back as a gap list, and no page renders. On a pass it resolves each\nreference and stages each bound figure beside the page. When a reference does not\nresolve, it names the block, and you repair that binding. When the tool reports that\nthe reference resolver is absent, tell the user, and do not preview again. Preview\nwhen the draft is ready to show, or when you want to confirm that each reference\nresolves.\n\n## Do NOT\n\n- **Transcribe a number from memory.** Every metric, every table cell, and every\n  figure binds to a reference that resolves against the pinned evidence.\n- **Start a run, or change the analysis.** You read the analysis; you never run it\n  and never write to it. You hold no tool that does either, and that is by design.\n- **Invent a path.** Name a file by what a search or a run gave you. Never guess a\n  location, and never hardcode one.\n- **Reach outside the pinned evidence.** A reference binds to the frozen snapshot\n  of this session alone. Do not cite an artifact that the snapshot does not hold.\n- **Rebuild when one amend serves.** One feedback is one block change. Change, move,\n  or remove that block by its id, and do not re-author the report.\n- **Leave a gap unread.** When `finish_draft` or `preview_report` reports a gap or\n  an unresolved reference, repair it. Do not present a report that does not finish.\n";
+export declare const reportSessionPrompt = "# Report Builder\n\nYou compose a scientific report for the user, one block at a time, and you ground\nevery claim in the analysis. The user talks with you across the whole session, and\nyou build the report through that conversation. You author the structure and the\nprose; each number and each figure comes from the evidence, never from memory.\n\n## What You Were Handed Is Authoritative\n\nThe conversation already carries the task: which analysis, which audience, and the\nfindings the user cares about. Start from what is in front of you. Reach for a read\ntool only where the context is thin, and reach in a targeted way:\n\n- `inspect_data_profile` \u2014 what the dataset is: its design, its organism, its\n  per-file types. Read it when you must state a fact about the data itself.\n- `inspect_run` \u2014 what a run produced, and where its outputs are. Read it when you\n  must ground a claim in a run's results.\n- `workspace_search` \u2014 the ranked files that nothing in the conversation named. It\n  gives descriptions and metadata, not contents.\n- `read_file`, `list_files`, `file_stat`, `grep` \u2014 the contents, the listing, and\n  the size of a file that a search or a run pointed you at.\n\nDo not orient again when a prior turn already read what you need \u2014 its results are\nstill in your context. To reach further is targeted, not a fresh sweep.\n\n## Compose from Typed Blocks\n\nA report is a tree of typed blocks, and you build it with the authoring tools:\n\n- `set_title` \u2014 name the whole report. A draft starts with none, and it needs one.\n- `add_block` \u2014 add one section, or one atom inside a section. You choose the id,\n  and it is unique in the draft. A section holds atoms. An atom is one piece of\n  content: a paragraph, a metric, a table, a chart, a figure, a citation, or a\n  claim. The block schema of `add_block` gives every kind and its fields.\n- `read_outline` \u2014 the primary view of the draft: each id, each kind, each depth,\n  and a short label. Read the outline, not the whole draft, to see where you are.\n- `read_block` \u2014 one block in full, when its outline label is not enough.\n\nBuild the report as a shape first, then fill each section. Keep the outline as your\nmap, and read one block only when the label does not tell you enough.\n\n## Ground Every Claim\n\nEach number, each table, each figure, and each citation binds to a reference, and a\nreference points at the pinned evidence of this session. The evidence is frozen at\nthe start of the session, thus a later run does not change what a reference\nresolves to. Bind every value. Never transcribe a number that you remember.\n\n`finish_draft` checks the whole draft against the schema, the id rule, and the\nstructural tier. It returns each completeness gap, or the finished document. Read\nthe gaps, repair the draft, and finish again.\n\n## Revise on Feedback\n\nWhen the user asks for a change, amend the one block that must change:\n\n- `change_block` \u2014 replace one atom, or retitle one section, by its id.\n- `move_block` \u2014 move one block to a new place by its id.\n- `remove_block` \u2014 remove one block, and its subtree, by its id.\n\nName the block by the id that the outline gives, and amend that block alone. Do not\nrebuild the report to make one change.\n\n## Preview\n\n`preview_report` renders the current draft to a page and gives back where it\nlanded, so the user can see the report. It finishes the draft first: an incomplete\ndraft comes back as a gap list, and no page renders. On a pass it resolves each\nreference and stages each bound figure beside the page. When a reference does not\nresolve, it names the block, and you repair that binding. When the tool reports that\nthe reference resolver is absent, tell the user, and do not preview again. Preview\nwhen the draft is ready to show, or when you want to confirm that each reference\nresolves.\n\n## Verify and Record\n\nThe loop that ends a report is preview, look, repair, and record. Run it in order:\n\n- `preview_report` renders the current draft to a page. The Preview section above\n  gives its rules.\n- `examine_page` opens the rendered page in a real browser. It gives back a\n  screenshot, the console errors, and the failed requests. Look at the page.\n- Repair each fault that the look shows. A broken layout, an absent chart, and a\n  failed request each name a block or a binding that you repair.\n- `record_report_version` records the report as one version. It records only after\n  you look at the current page. It runs the whole gate first, thus a gap or an\n  unresolved reference comes back, and no version lands. A thread holds one version.\n\nLook again after each repair, because a repair changes the page. Record when the\npage reads clean.\n\n## Do NOT\n\n- **Transcribe a number from memory.** Every metric, every table cell, and every\n  figure binds to a reference that resolves against the pinned evidence.\n- **Start a run, or change the analysis.** You read the analysis; you never run it\n  and never write to it. You hold no tool that does either, and that is by design.\n- **Invent a path.** Name a file by what a search or a run gave you. Never guess a\n  location, and never hardcode one.\n- **Reach outside the pinned evidence.** A reference binds to the frozen snapshot\n  of this session alone. Do not cite an artifact that the snapshot does not hold.\n- **Rebuild when one amend serves.** One feedback is one block change. Change, move,\n  or remove that block by its id, and do not re-author the report.\n- **Leave a gap unread.** When `finish_draft` or `preview_report` reports a gap or\n  an unresolved reference, repair it. Do not present a report that does not finish.\n- **Spiral on a cosmetic doubt.** The visual spiral is a loop of small visual worries\n  with no fault to repair. Look one time, then repair a real fault: a broken layout, an\n  absent chart, or a failed request. A matter of taste is not a fault. When the page\n  reads clean, record.\n";

package/dist/prompts/report-session.js

@@ -72,6 +72,23 @@ the reference resolver is absent, tell the user, and do not preview again. Previ
 when the draft is ready to show, or when you want to confirm that each reference
 resolves.
 
+## Verify and Record
+
+The loop that ends a report is preview, look, repair, and record. Run it in order:
+
+- \`preview_report\` renders the current draft to a page. The Preview section above
+  gives its rules.
+- \`examine_page\` opens the rendered page in a real browser. It gives back a
+  screenshot, the console errors, and the failed requests. Look at the page.
+- Repair each fault that the look shows. A broken layout, an absent chart, and a
+  failed request each name a block or a binding that you repair.
+- \`record_report_version\` records the report as one version. It records only after
+  you look at the current page. It runs the whole gate first, thus a gap or an
+  unresolved reference comes back, and no version lands. A thread holds one version.
+
+Look again after each repair, because a repair changes the page. Record when the
+page reads clean.
+
 ## Do NOT
 
 - **Transcribe a number from memory.** Every metric, every table cell, and every
@@ -86,4 +103,8 @@ resolves.
   or remove that block by its id, and do not re-author the report.
 - **Leave a gap unread.** When \`finish_draft\` or \`preview_report\` reports a gap or
   an unresolved reference, repair it. Do not present a report that does not finish.
+- **Spiral on a cosmetic doubt.** The visual spiral is a loop of small visual worries
+  with no fault to repair. Look one time, then repair a real fault: a broken layout, an
+  absent chart, or a failed request. A matter of taste is not a fault. When the page
+  reads clean, record.
 `;

package/dist/providers/ai-sdk.d.ts

@@ -23,6 +23,11 @@ export declare const RETRY_MAX_DELAY_MS = 30000;
  *
  * Lower it per-config for servers that validate `prompt + max_tokens <= context`
  * (vLLM and similar) against a small-context model.
+ *
+ * The openai arm takes no value from this default. `@ai-sdk/openai` clamps
+ * nothing per model, and it puts the number on the wire as it is. Thus a model
+ * whose own cap is smaller answers 400 on each call. That arm sends no ceiling,
+ * and the server then enforces the true cap of the model.
  */
 export declare const DEFAULT_MAX_OUTPUT_TOKENS = 64000;
 export interface AiSdkProviderDeps {
@@ -30,8 +35,14 @@ export interface AiSdkProviderDeps {
     readonly resolveBilling: ResolveBilling;
     readonly capabilities?: Partial<ProviderCapabilities>;
     readonly logger?: Logger;
-    /** Output-token ceiling per request. Defaults to {@link DEFAULT_MAX_OUTPUT_TOKENS}. */
-    readonly maxOutputTokens?: number;
+    /**
+     * Output-token ceiling per request. Defaults to
+     * {@link DEFAULT_MAX_OUTPUT_TOKENS}. The value `"provider-maximum"` sends the
+     * SDK no ceiling, and the server then enforces the true cap of the model. Use
+     * the sentinel for a wire whose SDK puts the number on the request as it is,
+     * because a ceiling above the cap of the model fails the call.
+     */
+    readonly maxOutputTokens?: number | "provider-maximum";
     /** The retry limit of the harness envelope. Defaults to {@link RETRY_MAX_RETRIES}. */
     readonly maxRetries?: number;
     /**
@@ -45,7 +56,7 @@ export interface AiSdkProviderDeps {
 }
 /**
  * Connection + model configuration for one `ChatProvider`, discriminated by
- * wire protocol (`anthropic` | `openai-compatible`). The `model` is the wire
+ * wire protocol (`anthropic` | `openai` | `openai-compatible`). The `model` is the wire
  * model bound into the provider at construction: `ChatRequest` carries no model
  * field (see `./types.ts`), so a config value describes exactly one model over
  * one connection. An embedder running distinct models builds one provider per
@@ -83,6 +94,73 @@ export type AiSdkProviderConfig = {
      * keeps the default of 10.
      */
     readonly maxRetries?: number;
+} | {
+    readonly kind: "openai";
+    readonly baseURL?: string;
+    readonly apiKey: string;
+    readonly model: string;
+    readonly fetch?: FetchLike;
+    readonly capabilities?: Partial<ProviderCapabilities>;
+    /**
+     * Output-token ceiling per request. An unset value sends no ceiling, and
+     * the model cap of the server governs the reply. The Responses wire holds
+     * no low default, thus the omission cannot truncate a reply. Set a number
+     * to hold the reply under a lower ceiling than the cap of the model.
+     */
+    readonly maxOutputTokens?: number;
+    /**
+     * The bound for each silent interval of a request attempt, in
+     * milliseconds. The value bounds the wait until the response starts, and
+     * each gap between two content chunks of a stream, per attempt. A chunk
+     * that carries no content, for example a keep-alive comment, does not
+     * reset the gap bound. When the field is absent, the provider installs no
+     * guard, and its behavior does not change.
+     *
+     * The harness lifts the transport floor of Bun: the guard adds
+     * `timeout: false` to the fetch init, thus the idle cut of 300 seconds
+     * does not apply. Under Node the floor of undici stays. Thus a Node
+     * embedder that sets a value above 300 seconds supplies a `fetch` whose
+     * dispatcher raises that limit.
+     */
+    readonly requestTimeoutMs?: number;
+    /**
+     * The retry limit of the harness envelope. The envelope uses this value
+     * in place of the default limit. When the field is absent, the envelope
+     * keeps the default of 10.
+     */
+    readonly maxRetries?: number;
+    /**
+     * NOTICE: this value is the retention directive of the Responses wire.
+     *
+     * An unset value lets the OpenAI server keep the response for 30 days.
+     * The dashboard logs show that response, and a caller can retrieve it by
+     * id. Thus the arm always sends an explicit value. The default is
+     * `false`, and an analysis payload does not persist at OpenAI.
+     *
+     * An unset value is also not neutral inside the SDK. When the SDK sees
+     * no explicit `false`, its input converter assumes storage. It then
+     * replaces a round-tripped item with an `item_reference` entry. Such a
+     * reference fails with a 404 under Zero Data Retention, and it fails
+     * after the 30-day expiry.
+     *
+     * An explicit `false` selects the stateless reasoning path of the SDK.
+     * The SDK adds `include: ["reasoning.encrypted_content"]` for a
+     * reasoning-family model id. It captures the blob on `providerMetadata`,
+     * and it replays the blob from the history of the thread. The SDK strips
+     * a reasoning part that lost its blob, and it warns. That warning reaches
+     * the harness logger through the SDK warning hook.
+     *
+     * One thread must keep one mode. The wire captures the history of a turn
+     * under the mode of that turn. If a later turn replays a history of the
+     * `false` mode under storage, the SDK emits a reference onto an item that
+     * the server never stored.
+     *
+     * An operator can override the default with `true`. The dashboard then
+     * shows the trail of the thread, and a caller can retrieve a response by
+     * id. The harness does not use `previous_response_id`, and it does not
+     * use `conversation`. This is true for the two modes.
+     */
+    readonly store?: boolean;
 } | {
     readonly kind: "openai-compatible";
     readonly name: string;

package/dist/providers/ai-sdk.js

@@ -1,5 +1,6 @@
 import { generateText, streamText, wrapLanguageModel, } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { APICallError } from "@ai-sdk/provider";
 import { retryWithExponentialBackoff } from "@ai-sdk/provider-utils";
@@ -28,6 +29,11 @@ export const RETRY_MAX_DELAY_MS = 30_000;
  *
  * Lower it per-config for servers that validate `prompt + max_tokens <= context`
  * (vLLM and similar) against a small-context model.
+ *
+ * The openai arm takes no value from this default. `@ai-sdk/openai` clamps
+ * nothing per model, and it puts the number on the wire as it is. Thus a model
+ * whose own cap is smaller answers 400 on each call. That arm sends no ceiling,
+ * and the server then enforces the true cap of the model.
  */
 export const DEFAULT_MAX_OUTPUT_TOKENS = 64_000;
 /**
@@ -370,9 +376,20 @@ function abortedStreamFailure(signal, reason, requestTimeoutMs) {
     return new Error(reason ?? "The provider aborted the stream.");
 }
 export function createAiSdkProvider(deps) {
-    const capabilities = { toolCalling: deps.capabilities?.toolCalling ?? true };
+    const capabilities = {
+        toolCalling: deps.capabilities?.toolCalling ?? true,
+        // Propagate a picture flag only when the caller states it. An absent
+        // flag stays absent, thus the loop degrades to the next placement for a
+        // wire that carries no picture there.
+        ...(deps.capabilities?.imageToolResults !== undefined ? { imageToolResults: deps.capabilities.imageToolResults } : {}),
+        ...(deps.capabilities?.imageUserMessages !== undefined ? { imageUserMessages: deps.capabilities.imageUserMessages } : {}),
+    };
     const logger = (deps.logger ?? createNoopLogger()).named("providers.ai-sdk");
     const maxOutputTokens = deps.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
+    // The sentinel hands the SDK no ceiling, thus the request carries none and the
+    // server enforces the cap of the model. One binding feeds the call and the
+    // stream, thus the two cannot disagree about the ceiling of a request.
+    const outputCeiling = maxOutputTokens === "provider-maximum" ? {} : { maxOutputTokens };
     const maxRetries = deps.maxRetries ?? RETRY_MAX_RETRIES;
     const requestTimeoutMs = deps.requestTimeoutMs;
     const requestedModelId = requestedModelIdOf(deps.model);
@@ -392,7 +409,7 @@ export function createAiSdkProvider(deps) {
                         messages: sanitizeMessages(req.messages),
                         tools: req.tools,
                         toolChoice: req.toolChoice ?? "auto",
-                        maxOutputTokens,
+                        ...outputCeiling,
                         stopWhen: [],
                         // The harness envelope owns retries; leaving the SDK default in
                         // place would multiply attempts (10 outer × 3 inner).
@@ -436,17 +453,19 @@ export function createAiSdkProvider(deps) {
                     messages: sanitizeMessages(req.messages),
                     tools: req.tools,
                     toolChoice: req.toolChoice ?? "auto",
-                    maxOutputTokens,
+                    ...outputCeiling,
                     stopWhen: [],
                     maxRetries: 0,
                     headers,
                     abortSignal: signal,
-                    // The SDK bounds each gap between two content chunks of the body.
-                    // Its timer arms at the first part of the provider stream, thus the
-                    // wait until the response starts stays with the fetch guard. A
-                    // chunk that carries no content, for example a keep-alive comment,
-                    // produces no part, thus it does not reset this bound.
-                    ...(requestTimeoutMs !== undefined ? { timeout: { chunkMs: requestTimeoutMs } } : {}),
+                    // The fetch guard bounds the wait until the headers. Past the
+                    // headers the SDK owns two bounds: `firstChunkMs` covers the wait
+                    // for the first content chunk, and `chunkMs` covers each later
+                    // gap. The two take the same value, thus each silent interval of
+                    // the stream has the one configured bound. A chunk that carries
+                    // no content, for example a keep-alive comment, produces no part,
+                    // thus it feeds neither bound.
+                    ...(requestTimeoutMs !== undefined ? { timeout: { firstChunkMs: requestTimeoutMs, chunkMs: requestTimeoutMs } } : {}),
                     providerOptions: req.providerOptions,
                 });
                 const iterator = result.fullStream[Symbol.asyncIterator]();
@@ -581,6 +600,28 @@ export function wrapFetchWithRequestTimeout(fetchImpl, requestTimeoutMs) {
         }
     };
 }
+/**
+ * Bind one explicit `store` directive onto each call of a model.
+ *
+ * The middleware merges the value into the `openai` namespace of
+ * `providerOptions`. It keeps each other namespace, and it keeps each other key
+ * of the `openai` namespace, thus a cache directive of a different vendor rides
+ * through untouched. The arm value wins over a request-level `store`, because
+ * the retention mode belongs to the connection and not to one turn. A thread
+ * that mixes the two modes replays a reference onto an item that the server
+ * never stored.
+ */
+function withStoreDirective(model, store) {
+    return wrapLanguageModel({
+        model,
+        middleware: {
+            transformParams: async ({ params }) => ({
+                ...params,
+                providerOptions: { ...params.providerOptions, openai: { ...params.providerOptions?.openai, store } },
+            }),
+        },
+    });
+}
 /**
  * Realize an `AiSdkProviderConfig` into a `ChatProvider` bound to that config's
  * connection and model. The model is closed into the returned provider here (it
@@ -604,16 +645,56 @@ export function createConfiguredAiSdkProvider(deps) {
             apiKey: config.apiKey,
             fetch: effectiveFetch,
         });
+        // The Anthropic Messages wire renders an image block inside a
+        // tool_result, thus the loop can send a picture. A custom baseURL can
+        // front a different backend that stringifies the block. Thus the
+        // harness asserts the capability only for the default endpoint. An
+        // absent flag means "cannot carry", thus a config with a custom baseURL
+        // must declare the capability. A config value overrides this default in
+        // both directions.
+        const pictureDefault = config.baseURL === undefined ? { imageToolResults: true } : {};
         return createAiSdkProvider({
             model: provider.chat(config.model),
             resolveBilling: deps.resolveBilling,
-            capabilities: config.capabilities,
+            capabilities: { ...pictureDefault, ...config.capabilities },
             logger: deps.logger,
             ...(config.maxOutputTokens !== undefined ? { maxOutputTokens: config.maxOutputTokens } : {}),
             ...(config.maxRetries !== undefined ? { maxRetries: config.maxRetries } : {}),
             ...(requestTimeoutMs !== undefined ? { requestTimeoutMs } : {}),
         });
     }
+    if (config.kind === "openai") {
+        const provider = createOpenAI({
+            baseURL: config.baseURL,
+            apiKey: config.apiKey,
+            fetch: effectiveFetch,
+        });
+        // The Responses wire renders an image block inside a function-call
+        // output, thus the loop can send a picture. A custom baseURL can front
+        // a different backend that stringifies the block. Thus the harness
+        // asserts the capability only for the default endpoint. An absent flag
+        // means "cannot carry", thus a config with a custom baseURL must
+        // declare the capability. A config value overrides this default in both
+        // directions.
+        const pictureDefault = config.baseURL === undefined ? { imageToolResults: true } : {};
+        return createAiSdkProvider({
+            // The explicit Responses binding pins the wire here. The bare
+            // factory callable of the package resolves to the same path today,
+            // but nothing in the package holds it there.
+            model: withStoreDirective(provider.responses(config.model), config.store ?? false),
+            resolveBilling: deps.resolveBilling,
+            capabilities: { ...pictureDefault, ...config.capabilities },
+            logger: deps.logger,
+            // The package puts this number on the wire as it is, and it clamps
+            // nothing per model. Thus the shared default of 64000 breaks each call
+            // to a model with a smaller cap, with a 400 that no retry can pass. An
+            // unset config sends no ceiling, and the server holds the reply at the
+            // cap of the model.
+            maxOutputTokens: config.maxOutputTokens ?? "provider-maximum",
+            ...(config.maxRetries !== undefined ? { maxRetries: config.maxRetries } : {}),
+            ...(requestTimeoutMs !== undefined ? { requestTimeoutMs } : {}),
+        });
+    }
     const provider = createOpenAICompatible({
         name: config.name,
         baseURL: config.baseURL,

package/dist/providers/types.d.ts

@@ -13,6 +13,23 @@ import type { ProviderError } from "./errors.js";
 export type { FinishReason, LanguageModel, ModelMessage, ProviderOptions, ToolSet };
 export interface ProviderCapabilities {
     readonly toolCalling: boolean;
+    /**
+     * Whether the wire can carry a picture inside a tool result. The loop moves a
+     * tool's picture into an image content block on the tool-result message. A
+     * wire that renders that block sets this flag. A wire that stringifies the
+     * block into text leaves it absent, and the loop then drops the picture and
+     * keeps the text, because base64 text floods the context and the model cannot
+     * see it. Absent means "cannot carry", never "unknown".
+     */
+    readonly imageToolResults?: boolean;
+    /**
+     * Whether the wire can carry a picture inside a user message. The loop uses
+     * this placement only when the tool result cannot carry the picture. The tool
+     * result then keeps its JSON text, and one user message after the tool message
+     * of the round carries the bytes. Absent means "cannot carry", never
+     * "unknown".
+     */
+    readonly imageUserMessages?: boolean;
 }
 export interface ChatRequest {
     readonly system: string;

package/dist/report-model/assert-rules.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The assert rules of the value tier. A resolver reads a fresh value, and these functions match it
+ * against the authored belief.
+ *
+ * Each realization of the resolver calls these functions. Thus one semantics exists, and the fixture
+ * stays the executable specification of the value tier.
+ */
+import type { Reference, UnresolvedReference } from "../contracts/report-reference.js";
+/**
+ * Read an authored value or a resolved cell as a finite number.
+ *
+ * A text-backed artifact such as a CSV holds every cell as a string, thus a numeric column arrives as
+ * `"0.01"` and not as `0.01`. A comparison that respects the JavaScript type would fail an author who
+ * states the number, and the arithmetic of a derivation could never run over a real CSV.
+ *
+ * The parse reads the whole string, thus `"12 genes"` stays text and never reads as 12. `Number` accepts
+ * the exponent form that a p-value uses, for example `"1.2e-45"`. A blank string is not a number, because
+ * `Number("")` gives 0 and an empty cell must never read as zero.
+ */
+export declare function asFiniteNumber(value: string | number): number | undefined;
+/**
+ * Match a row-filter value against a resolved cell.
+ *
+ * A text-backed artifact such as a CSV holds every cell as a string, thus a filter value of `3` must
+ * select the cell `"3"`. The compare reads both sides as a finite number, and it selects the row where the
+ * two numbers are equal. A side that is not a finite number compares by exact value, thus a text key
+ * selects by its exact text. The match is exact and carries no tolerance, because a filter names a
+ * discrete key and not a computed value with float noise.
+ */
+export declare function cellMatchesFilterValue(cell: string | number | null | undefined, filterValue: string | number): boolean;
+/**
+ * Match a resolved value against an authored one.
+ *
+ * The comparison is numeric whenever both sides read as a finite number, thus the CSV cell `"0.01"`
+ * matches the number 0.01 that an author states. An authored tolerance is an absolute difference, and it
+ * is the author's own statement of how close is close enough. With no tolerance the comparison is
+ * relative, because an exact match would fail on the float noise of a computed value. Any other pair
+ * matches on exact equality.
+ */
+export declare function valuesMatch(expected: string | number, actual: string | number, tolerance: number | undefined): boolean;
+/** Match a resolved scalar against the authored value, under the authored tolerance. */
+export declare function checkValueAssertion(reference: Reference, expected: string | number | undefined, tolerance: number | undefined, resolved: string | number): UnresolvedReference | undefined;
+/** Match the resolved citation key against the authored value. The key carries its `idKind:` prefix. */
+export declare function checkCitationAssertion(reference: Reference, expected: string | undefined, resolved: string): UnresolvedReference | undefined;

package/dist/report-model/assert-rules.js

@@ -0,0 +1,97 @@
+/**
+ * The assert rules of the value tier. A resolver reads a fresh value, and these functions match it
+ * against the authored belief.
+ *
+ * Each realization of the resolver calls these functions. Thus one semantics exists, and the fixture
+ * stays the executable specification of the value tier.
+ */
+/**
+ * The relative epsilon of a value match with no authored tolerance.
+ *
+ * Float arithmetic shifts a computed value in its last bits. For example, `0.3 - 0.1` gives
+ * 0.19999999999999998, and exact equality would report that noise as a fabrication.
+ *
+ * The epsilon absorbs the noise and nothing else. It is far below the difference that a rounded figure
+ * makes, thus an author who writes 0.05 against a true 0.0499 still fails. An author who wants a rounded
+ * figure to pass states a `tolerance`, which is the one place where the intent belongs.
+ */
+const RELATIVE_EPSILON = 1e-9;
+/**
+ * Read an authored value or a resolved cell as a finite number.
+ *
+ * A text-backed artifact such as a CSV holds every cell as a string, thus a numeric column arrives as
+ * `"0.01"` and not as `0.01`. A comparison that respects the JavaScript type would fail an author who
+ * states the number, and the arithmetic of a derivation could never run over a real CSV.
+ *
+ * The parse reads the whole string, thus `"12 genes"` stays text and never reads as 12. `Number` accepts
+ * the exponent form that a p-value uses, for example `"1.2e-45"`. A blank string is not a number, because
+ * `Number("")` gives 0 and an empty cell must never read as zero.
+ */
+export function asFiniteNumber(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (value.trim() === "") {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+/**
+ * Match a row-filter value against a resolved cell.
+ *
+ * A text-backed artifact such as a CSV holds every cell as a string, thus a filter value of `3` must
+ * select the cell `"3"`. The compare reads both sides as a finite number, and it selects the row where the
+ * two numbers are equal. A side that is not a finite number compares by exact value, thus a text key
+ * selects by its exact text. The match is exact and carries no tolerance, because a filter names a
+ * discrete key and not a computed value with float noise.
+ */
+export function cellMatchesFilterValue(cell, filterValue) {
+    if (cell === null || cell === undefined) {
+        return false;
+    }
+    const cellNumber = asFiniteNumber(cell);
+    const filterNumber = asFiniteNumber(filterValue);
+    if (cellNumber !== undefined && filterNumber !== undefined) {
+        return cellNumber === filterNumber;
+    }
+    return cell === filterValue;
+}
+/** Name a value with its type, so that a failed match never reads as two identical values. */
+function describeValue(value) {
+    return typeof value === "string" ? `the string ${JSON.stringify(value)}` : `the number ${value}`;
+}
+/**
+ * Match a resolved value against an authored one.
+ *
+ * The comparison is numeric whenever both sides read as a finite number, thus the CSV cell `"0.01"`
+ * matches the number 0.01 that an author states. An authored tolerance is an absolute difference, and it
+ * is the author's own statement of how close is close enough. With no tolerance the comparison is
+ * relative, because an exact match would fail on the float noise of a computed value. Any other pair
+ * matches on exact equality.
+ */
+export function valuesMatch(expected, actual, tolerance) {
+    const expectedNumber = asFiniteNumber(expected);
+    const actualNumber = asFiniteNumber(actual);
+    if (expectedNumber !== undefined && actualNumber !== undefined) {
+        if (tolerance !== undefined) {
+            return Math.abs(expectedNumber - actualNumber) <= tolerance;
+        }
+        return Math.abs(expectedNumber - actualNumber) <= RELATIVE_EPSILON * Math.max(1, Math.abs(expectedNumber), Math.abs(actualNumber));
+    }
+    return expected === actual;
+}
+/** Match a resolved scalar against the authored value, under the authored tolerance. */
+export function checkValueAssertion(reference, expected, tolerance, resolved) {
+    if (expected === undefined || valuesMatch(expected, resolved, tolerance)) {
+        return undefined;
+    }
+    return { reference, reason: "assertion-failed", detail: `expected ${describeValue(expected)} but resolved ${describeValue(resolved)}` };
+}
+/** Match the resolved citation key against the authored value. The key carries its `idKind:` prefix. */
+export function checkCitationAssertion(reference, expected, resolved) {
+    if (expected === undefined || expected === resolved) {
+        return undefined;
+    }
+    return { reference, reason: "assertion-failed", detail: `expected ${String(expected)} but resolved citation ${resolved}` };
+}

package/dist/report-model/draft-hash.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The one hash of a draft document.
+ *
+ * The look-before-record rule rides two durable markers, and each marker holds a hash of the draft. A
+ * stamp writes a hash, and a compare reads one. Both call this one function, thus two serializations of one
+ * document cannot split.
+ *
+ * The function serializes the draft with sorted object keys, and it hashes the text with sha256. The sort
+ * makes the hash independent of key order. Thus two objects with the same values and a different key order
+ * give one hash, and a marker survives a round trip through storage.
+ */
+import type { DraftDocument } from "./draft.js";
+/** The sha256 hash of the draft, over a JSON serialization with sorted keys. */
+export declare function computeDraftHash(document: DraftDocument): string;

package/dist/report-model/draft-hash.js

@@ -0,0 +1,36 @@
+/**
+ * The one hash of a draft document.
+ *
+ * The look-before-record rule rides two durable markers, and each marker holds a hash of the draft. A
+ * stamp writes a hash, and a compare reads one. Both call this one function, thus two serializations of one
+ * document cannot split.
+ *
+ * The function serializes the draft with sorted object keys, and it hashes the text with sha256. The sort
+ * makes the hash independent of key order. Thus two objects with the same values and a different key order
+ * give one hash, and a marker survives a round trip through storage.
+ */
+import { createHash } from "node:crypto";
+/**
+ * Give back a copy of a value with each object key in sorted order, at every depth.
+ *
+ * An array keeps its order, because the order of an array is data. An object gets its keys in one canonical
+ * order, thus the serialization does not depend on the order that a producer wrote the keys.
+ */
+function canonicalize(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonicalize);
+    }
+    if (value !== null && typeof value === "object") {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = canonicalize(value[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+/** The sha256 hash of the draft, over a JSON serialization with sorted keys. */
+export function computeDraftHash(document) {
+    const canonical = JSON.stringify(canonicalize(document));
+    return createHash("sha256").update(canonical).digest("hex");
+}