@aestheticfunction/dspack-gen 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## 0.1.0 — first public release
+
+The generation and governance pipeline for dspack contracts, previously
+consumed only in-repo and via the bundled core in ds-mcp, published as a
+package.
+
+- Root entry (`@aestheticfunction/dspack-gen`): model adapters
+  (Ollama/Anthropic/scripted), `runPipeline` (generate → S1/S2/S3 lint →
+  bounded repair → protocol emission → audit report), repair-message
+  rendering, audit report rendering, and the eval-matrix runner.
+- `/core` subpath: the zero-network, emitter-free compiler + linter
+  (`compileContext`, `lintSurface`, generation-schema builder) that ds-mcp
+  consumes; the boundary is test-enforced (`src/core/core-boundary.test.ts`).
+- `dspack-gen` CLI bin: `context`, `lint`, `run`, `serve` (localhost NDJSON
+  streaming of the pipeline). Exit codes: 0 clean, 1 usage/internal,
+  2 governance failure, 3 emitter gate, 4 unknown rule type.
+- Requires Node >= 20. ESM only.

package/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and derivative works thereof.
+
+      "Contribution" shall mean, as defined in the Licensor's terms of
+      contributing, any work of authorship, including the original version of
+      the Work and any modifications or additions to that Work or Derivative
+      Works of the Work, submitted to the Licensor for inclusion in the Work
+      by the copyright owner or by an individual or Legal Entity authorized to
+      submit on behalf of the copyright owner. For the purposes of this
+      definition, "submitted" means any form of electronic, verbal, or written
+      communication sent to the Licensor or its representatives, including but
+      not limited to communication on electronic mailing lists, source code
+      control systems, and issue tracking systems that are managed by, or on
+      behalf of, the Licensor for the purpose of discussing and improving the
+      Work, but excluding communication that is conspicuously marked or
+      otherwise designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and incorporated
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by the combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" file as part of its
+          distribution, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, in
+          at least one of the following places: within a NOTICE text
+          file distributed as part of the Derivative Works; within
+          the Source form or documentation, if provided along with the
+          Derivative Works; or, within a display generated by the
+          Derivative Works, if and wherever such third-party notices
+          normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License.
+          You may add Your own attribution notices within Derivative
+          Works that You distribute, alongside or as an addition to
+          the NOTICE text from the Work, provided that such additional
+          attribution notices cannot be construed as modifying the License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of the
+      Contribution(s), provided that You also comply with the conditions
+      stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or Liability. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a fee
+      for, acceptance of support, warranty, indemnity, or other liability
+      obligations and/or rights consistent with this License. However, in
+      accepting such obligations, You may offer such obligations only on
+      Your behalf and on Your sole responsibility, not on behalf of any
+      other Contributor, and only if You agree to indemnify, defend, and
+      hold each Contributor harmless for any liability incurred by, or
+      claims asserted against, such Contributor by reason of your accepting
+      any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format please. Also, it is recommended
+      that a file or directory name and description of purpose be included
+      on the same "first page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+---
+
+Copyright 2026 Aesthetic Function, LLC

package/README.md

@@ -0,0 +1,147 @@
+# dspack-gen
+
+**Generation + governance pipeline for [dspack](https://github.com/aestheticfunction/dspack)
+contracts.** Compiles a dspack v0.3/v0.4 contract into generation context, generates dspack
+surfaces via schema-constrained LLMs (Ollama local or hosted — interchangeable adapters),
+lints them deterministically against the contract's governance rules, repairs bounded, emits
+to protocols (A2UI and json-render via
+[dspack-emit](https://github.com/aestheticfunction/dspack-emit)), and
+produces a versioned audit report.
+
+> *A2UI defines what can render. dspack defines what is correct.*
+
+**Status: Milestones 1 and 2 complete.** Tags
+[m1](https://github.com/aestheticfunction/dspack-gen/releases/tag/m1) and
+[m2](https://github.com/aestheticfunction/dspack-gen/releases/tag/m2); write-ups in
+[docs/m1-report.md](docs/m1-report.md) and [docs/m2-report.md](docs/m2-report.md),
+findings in [docs/findings.md](docs/findings.md). M3 (dspack v0.4 and a second
+contract) is in progress.
+The emitter is consumed from npm as `@aestheticfunction/dspack-emit`
+(renamed from `@aestheticfunction/dspack-to-a2ui` with the ADR-D2 repo
+rename; the old package is deprecated with a pointer).
+
+## The three layers (never collapse them)
+
+1. **Schema** answers *"can this object exist"* — the generation schema encodes vocabulary and
+   shape only, never governance.
+2. **Linter** answers *"is this object correct"* — deterministic typed rules (gate S3), each
+   with a rationale.
+3. **Renderer** answers *"can this render"* — protocol emitters compile the surface; the
+   target's gates (A1–A3 for A2UI) validate the result.
+
+## Gates
+
+| Gate | Check | Where |
+|---|---|---|
+| S1 | generic dspack surface schema | here (pre-emission) |
+| S2 | contract vocabulary (components, sub-components, props, enum values, slots) | here (pre-emission) |
+| S3 | governance rules (typed, deterministic, rationale-bearing) | here (pre-emission) |
+| A1–A3 | schema-compile / catalog-shape / instance validation | dspack-emit (per emitted target) |
+
+S1/S2 are checks on **any** produced surface; constrained decoding may implement S2 during
+generation but the gates are always reported independently — the S0 spike found Ollama's mlx
+engine silently ignoring `format`, which is exactly why.
+
+## CLI
+
+```bash
+npm run context -- --dspack fixtures/shadcn.v0_4.dspack.json --intent destructive-action
+# prints { system, schema, fewshot } — the compiled generation context
+```
+
+`lint` (S1–S3) and `run` (full pipeline) land in later M1 PRs.
+
+### Exit codes (whole CLI surface)
+
+| Code | Meaning |
+|---|---|
+| 0 | clean |
+| 1 | internal / usage error |
+| 2 | governance failure (any S-gate error) |
+| 3 | emitter-gate failure (A1–A3 or target equivalent) |
+| 4 | unknown rule type (fail-loud; never silently skipped) |
+
+(Distinct from dspack-emit's exit codes, where `3` = strict-coverage failure and `4` =
+surface-emission failure.)
+
+## Eval harness
+
+```bash
+npm run eval -- --adapter fake --matrix eval/matrix.fake.json   # deterministic; the CI gate
+npm run eval -- --adapter live --matrix eval/matrix.json        # documented live run; never CI
+npm run eval -- --adapter live --matrix eval/matrix.json --out out/eval/<dir> --resume   # resume an interrupted run
+npm run eval:assert -- --results out/eval/fake/results.json --model <ref> --min-repair-success 0.9
+```
+
+Every cell run goes through the same `runPipeline` as the CLI and demo; the
+harness only iterates and aggregates. **Model ids live in `eval/matrix.json`
+(config), never in code.** Per cell (model × prompt × repair template,
+`runsPerCell` runs): schema-validity, first-attempt-violation, repair-success
+(null over zero violations), end-to-end pass rates, and the count of S3-clean
+surfaces refused by emitter gates (the ADR-D1 signal; `p10`–`p12` probe it
+deliberately). Prompts span repair shapes — substitution, addition, deletion,
+restructuring — and every prompt crosses the two ADR-7 repair templates
+(`standard` vs `permit-restructuring`, a one-instruction-line delta recorded
+in each audit report). One run can never kill the matrix: adapter transport failures are typed
+(`failed-adapter`, with a report) and anything that still escapes a run is
+contained as an explicit `error` run — visible in the distribution with a
+retained `.error.json`, excluded from the model-behavior rate denominators
+(`errorRuns` reports the count). `--resume` skips already-retained reports
+and retries error records. Every run's audit report is retained under
+`out/eval/…/reports/`; `results.json` is the artifact, `report.md` the
+derived view; findings go to [docs/findings.md](docs/findings.md) at measured
+strength. The hosted-model `eval:assert` threshold is the only hard eval gate
+in M2; local models are report-only.
+
+## Library
+
+```bash
+npm install @aestheticfunction/dspack-gen
+```
+
+ESM only, Node >= 20. The root entry is the full pipeline:
+
+```ts
+import { runPipeline, adapterFor } from "@aestheticfunction/dspack-gen";
+import { readFileSync } from "node:fs";
+
+const contract = JSON.parse(readFileSync("astryx.dspack.json", "utf8"));
+const result = await runPipeline({
+  contract,
+  intent: "destructive-action",
+  prompt: "a screen to delete a project",
+  adapter: adapterFor("ollama:gemma3"),
+});
+console.log(result.report.outcome, result.exitCode);
+```
+
+`@aestheticfunction/dspack-gen/core` is the **zero-network, emitter-free** subpath (compiler +
+linter) that [ds-mcp](https://github.com/aestheticfunction/ds-mcp) consumes without breaking
+its read-only/no-network security posture. The boundary is enforced by
+`src/core/core-boundary.test.ts`:
+
+```ts
+import { compileContext, lintSurface } from "@aestheticfunction/dspack-gen/core";
+```
+
+The CLI installs as `dspack-gen` (same commands as the repo scripts): `context`,
+`lint`, `run`, `serve`. Outside this repository, always pass `--dspack <contract>`
+(the `serve` default path points at a repo fixture).
+
+## Development
+
+```bash
+npm ci
+npm test          # vitest: golden context, generation-schema behavior, core boundary
+npm run check:sync  # contract-copy drift check vs the dspack repo (CI-run; --write re-syncs)
+```
+
+`fixtures/shadcn.v0_4.dspack.json` is a byte copy of the spec repo's
+`examples/shadcn-ui.dspack.json`; CI fails loudly if they diverge
+(dspack-gen#7). After `--write`, regenerate the derived goldens (context
+golden, F-fixture expected outputs, eval fake golden) and commit the sync +
+regeneration together.
+
+## License
+
+Apache-2.0. Copyright 2026 Aesthetic Function, LLC.

package/dist/adapters/anthropic.d.ts

@@ -0,0 +1,16 @@
+import { type FetchLike, type GenerateRequest, type GenerateResult, type GenerationAdapter } from "./types.js";
+export interface AnthropicAdapterOptions {
+    /** Required — no default model exists in code (ADR-9 as amended). */
+    model: string;
+    /** Defaults to the SDK's environment resolution (ANTHROPIC_API_KEY, auth token, profile). */
+    apiKey?: string;
+    baseURL?: string;
+    fetch?: FetchLike;
+}
+export declare class AnthropicAdapter implements GenerationAdapter {
+    readonly id: string;
+    private readonly model;
+    private readonly client;
+    constructor(options: AnthropicAdapterOptions);
+    generate(request: GenerateRequest): Promise<GenerateResult>;
+}

package/dist/adapters/anthropic.js

@@ -0,0 +1,71 @@
+/**
+ * Anthropic adapter — hosted generation via the official SDK with
+ * schema-constrained output (`output_config.format`, type json_schema).
+ *
+ * The generation schema is compatible by construction: depth-unrolled (the
+ * structured-outputs API rejects recursive schemas) and additionalProperties:
+ * false on every object. No sampling parameters are sent — they are removed
+ * on current Claude models. `stop_reason: "refusal"` is surfaced as a typed
+ * AdapterOutputError (never retried silently; retries are the repair loop's
+ * job and only for lint findings).
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { AdapterOutputError, parseJsonOutput, } from "./types.js";
+export class AnthropicAdapter {
+    id;
+    model;
+    client;
+    constructor(options) {
+        if (!options.model)
+            throw new Error("AnthropicAdapter requires an explicit model id (config/env/flag)");
+        this.model = options.model;
+        this.client = new Anthropic({
+            apiKey: options.apiKey,
+            baseURL: options.baseURL,
+            fetch: options.fetch,
+        });
+        this.id = `anthropic:${this.model}`;
+    }
+    async generate(request) {
+        // Typed transport: SDK connection/API errors surface as failed-adapter
+        // outcomes (with a report), never as raw exceptions that kill a matrix.
+        let response;
+        try {
+            response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: request.params?.maxTokens ?? 16000,
+                system: request.system,
+                messages: request.messages,
+                output_config: {
+                    format: { type: "json_schema", schema: request.jsonSchema },
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof AdapterOutputError)
+                throw error;
+            const name = error instanceof Error ? error.constructor.name : "unknown";
+            throw new AdapterOutputError(this.id, `transport failure (${name}): ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const message = response;
+        if (message.stop_reason === "refusal") {
+            throw new AdapterOutputError(this.id, "model refused the request (stop_reason: refusal)");
+        }
+        const raw = message.content
+            .filter((block) => block.type === "text")
+            .map((block) => block.text)
+            .join("");
+        if (raw === "")
+            throw new AdapterOutputError(this.id, "empty model output");
+        if (message.stop_reason === "max_tokens") {
+            throw new AdapterOutputError(this.id, "output truncated (stop_reason: max_tokens) — raise params.maxTokens", raw);
+        }
+        return {
+            json: parseJsonOutput(this.id, raw),
+            raw,
+            model: message.model,
+            usage: { inputTokens: message.usage.input_tokens, outputTokens: message.usage.output_tokens },
+            meta: { provider: "anthropic", stop_reason: message.stop_reason },
+        };
+    }
+}

package/dist/adapters/fake.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Scripted adapter — the deterministic instrument behind CI gates, the demo's
+ * verification mode, and the eval harness's golden runs. Returns the scripted
+ * outputs in order; a script entry of `{ error: "..." }` raises a typed
+ * AdapterOutputError instead.
+ */
+import { type GenerateRequest, type GenerateResult, type GenerationAdapter } from "./types.js";
+export type ScriptEntry = {
+    output: unknown;
+} | {
+    error: string;
+};
+export declare class ScriptedAdapter implements GenerationAdapter {
+    private readonly script;
+    readonly id = "fake:scripted";
+    /** Every request received, for assertions on repair-loop conversation state. */
+    readonly requests: GenerateRequest[];
+    private cursor;
+    constructor(script: ScriptEntry[]);
+    generate(request: GenerateRequest): Promise<GenerateResult>;
+}

package/dist/adapters/fake.js

@@ -0,0 +1,32 @@
+/**
+ * Scripted adapter — the deterministic instrument behind CI gates, the demo's
+ * verification mode, and the eval harness's golden runs. Returns the scripted
+ * outputs in order; a script entry of `{ error: "..." }` raises a typed
+ * AdapterOutputError instead.
+ */
+import { AdapterOutputError } from "./types.js";
+export class ScriptedAdapter {
+    script;
+    id = "fake:scripted";
+    /** Every request received, for assertions on repair-loop conversation state. */
+    requests = [];
+    cursor = 0;
+    constructor(script) {
+        this.script = script;
+    }
+    async generate(request) {
+        this.requests.push(request);
+        const entry = this.script[this.cursor++];
+        if (!entry)
+            throw new Error(`ScriptedAdapter: script exhausted after ${this.script.length} generation(s)`);
+        if ("error" in entry)
+            throw new AdapterOutputError(this.id, entry.error);
+        return {
+            json: entry.output,
+            raw: JSON.stringify(entry.output),
+            model: "fake-model",
+            usage: { inputTokens: 0, outputTokens: 0 },
+            meta: { provider: "fake" },
+        };
+    }
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export { OllamaAdapter, type OllamaAdapterOptions } from "./ollama.js";
+export { AnthropicAdapter, type AnthropicAdapterOptions } from "./anthropic.js";
+import { type GenerationAdapter } from "./types.js";
+/** Build an adapter from a `--model` reference (ollama:<id> | anthropic:<id>). */
+export declare function adapterFor(modelRef: string): GenerationAdapter;

package/dist/adapters/index.js

@@ -0,0 +1,11 @@
+export * from "./types.js";
+export { OllamaAdapter } from "./ollama.js";
+export { AnthropicAdapter } from "./anthropic.js";
+import { OllamaAdapter } from "./ollama.js";
+import { AnthropicAdapter } from "./anthropic.js";
+import { parseModelRef } from "./types.js";
+/** Build an adapter from a `--model` reference (ollama:<id> | anthropic:<id>). */
+export function adapterFor(modelRef) {
+    const { provider, model } = parseModelRef(modelRef);
+    return provider === "ollama" ? new OllamaAdapter({ model }) : new AnthropicAdapter({ model });
+}

package/dist/adapters/ollama.d.ts

@@ -0,0 +1,16 @@
+import { type FetchLike, type GenerateRequest, type GenerateResult, type GenerationAdapter } from "./types.js";
+export interface OllamaAdapterOptions {
+    /** Required — no default model exists in code (ADR-9 as amended). */
+    model: string;
+    /** Defaults to OLLAMA_HOST env or http://localhost:11434. */
+    host?: string;
+    fetch?: FetchLike;
+}
+export declare class OllamaAdapter implements GenerationAdapter {
+    readonly id: string;
+    private readonly model;
+    private readonly host;
+    private readonly fetchImpl;
+    constructor(options: OllamaAdapterOptions);
+    generate(request: GenerateRequest): Promise<GenerateResult>;
+}

package/dist/adapters/ollama.js

@@ -0,0 +1,91 @@
+/**
+ * Ollama adapter — local generation via structured outputs (`format` = the
+ * generation schema on /api/chat). Mandatory for the local path per the plan;
+ * there is no unconstrained-JSON fallback in this design.
+ *
+ * S0 spike caveat carried here: on mlx-engine models Ollama silently ignores
+ * `format`. The adapter cannot detect the engine from the chat response, so
+ * it records the model tag in `meta` and relies on gates S1/S2 to catch
+ * unconstrained output; non-JSON output raises AdapterOutputError.
+ */
+import { Agent } from "undici";
+import { AdapterOutputError, parseJsonOutput, } from "./types.js";
+/**
+ * Local inference is legitimately slow: a single 35B generation can exceed
+ * undici's default 300s headersTimeout, which killed runs at exactly ~301s
+ * in the 2026-07-03 eval (reports with zero attempts, "fetch failed").
+ * One long-lived dispatcher with the header/body timeouts raised to an hour
+ * — a deliberate ceiling, not "no timeout": a truly hung server should
+ * still fail rather than block a matrix forever.
+ */
+const LOCAL_INFERENCE_TIMEOUT_MS = 60 * 60 * 1000;
+const localInferenceDispatcher = new Agent({
+    headersTimeout: LOCAL_INFERENCE_TIMEOUT_MS,
+    bodyTimeout: LOCAL_INFERENCE_TIMEOUT_MS,
+});
+export class OllamaAdapter {
+    id;
+    model;
+    host;
+    fetchImpl;
+    constructor(options) {
+        if (!options.model)
+            throw new Error("OllamaAdapter requires an explicit model id (config/env/flag)");
+        this.model = options.model;
+        this.host = options.host ?? process.env.OLLAMA_HOST ?? "http://localhost:11434";
+        this.fetchImpl = options.fetch ?? fetch;
+        this.id = `ollama:${this.model}`;
+    }
+    async generate(request) {
+        const body = {
+            model: this.model,
+            stream: false,
+            format: request.jsonSchema,
+            options: { temperature: request.params?.temperature ?? 0.2 },
+            messages: [{ role: "system", content: request.system }, ...request.messages],
+        };
+        // The whole transport exchange is typed: a rejected fetch (connection
+        // reset, timeout under a large model load) must surface as a
+        // failed-adapter outcome with a report, never as a raw exception that
+        // kills a whole eval matrix (the 2026-07-03 live-run crash).
+        let data;
+        try {
+            const init = {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify(body),
+                // undici extension of fetch(init); ignored by injected test fetches.
+                dispatcher: localInferenceDispatcher,
+            };
+            const response = await this.fetchImpl(`${this.host}/api/chat`, init);
+            if (!response.ok) {
+                // Body read can itself fail on a broken stream — keep the HTTP
+                // status in the error either way.
+                const detail = await response.text().catch(() => "(response body unreadable)");
+                throw new AdapterOutputError(this.id, `HTTP ${response.status}: ${detail.slice(0, 300)}`);
+            }
+            data = (await response.json());
+        }
+        catch (error) {
+            if (error instanceof AdapterOutputError)
+                throw error;
+            throw new AdapterOutputError(this.id, `transport failure: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const raw = data.message?.content ?? "";
+        if (raw === "")
+            throw new AdapterOutputError(this.id, "empty model output");
+        return {
+            json: parseJsonOutput(this.id, raw),
+            raw,
+            model: data.model ?? this.model,
+            usage: { inputTokens: data.prompt_eval_count, outputTokens: data.eval_count },
+            meta: {
+                provider: "ollama",
+                total_duration: data.total_duration,
+                load_duration: data.load_duration,
+                prompt_eval_duration: data.prompt_eval_duration,
+                eval_duration: data.eval_duration,
+            },
+        };
+    }
+}