@nola-lang/providers 0.1.12 → 0.1.14

package/dist/anthropic.d.ts

@@ -9,6 +9,12 @@ export interface AnthropicOptions {
     fetch?: typeof globalThis.fetch;
     /** The Messages API requires max_tokens on every request. Default: 4096. */
     maxOutputTokens?: number;
+    /**
+     * Default true: the schema rides the API's structured-output field. false:
+     * nothing is sent on the wire and the schema is rendered into the system
+     * turn as a <schema> block — for a proxy or server that cannot enforce it.
+     */
+    structuredOutputs?: boolean;
 }
 /** A bare model string is shorthand for `{ model }` — every other option defaulted. */
 export declare function anthropic(optionsOrModel: AnthropicOptions | string): LanguageModel;

package/dist/anthropic.js

@@ -1,5 +1,5 @@
-import { NolaProviderError, parseRetryAfter } from "@nola-lang/core";
-import { ENVELOPE_NOTE, envelope, resolveRootRef } from "./wire.js";
+import { NolaProviderError, parseRetryAfter, renderPrompt } from "@nola-lang/core";
+import { ENVELOPE_NOTE, envelope, resolveRootRef, schemaNote } from "./wire.js";
 const DEFAULT_MAX_OUTPUT_TOKENS = 4096;
 /** A bare model string is shorthand for `{ model }` — every other option defaulted. */
 export function anthropic(optionsOrModel) {
@@ -10,26 +10,30 @@ export function anthropic(optionsOrModel) {
     const maxTokens = options.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
     return {
         name: "anthropic",
-        async complete(req) {
+        async infer(req) {
             const requestedAt = Date.now();
             const envName = options.apiKeyEnv ?? "ANTHROPIC_API_KEY";
             const apiKey = options.apiKey ?? process.env[envName];
             if (!apiKey) {
                 throw new NolaProviderError(`Anthropic API key not found: environment variable ${envName} is not set (checked process.env, including the project .env applied by the Nola loader) and no \`apiKey\` was passed to anthropic(). Fix: set ${envName}, or pass anthropic({ apiKeyEnv: "MY_VAR" }) or anthropic({ apiKey }) in nola.config.ts.`, { definitive: true });
             }
-            const { system: baseSystem, messages, output } = req.payload;
+            const { system: baseSystem, messages } = renderPrompt(req.intent);
+            const output = req.intent.output;
             const reqSchema = output.syntax === "json" ? output.schema : undefined;
             const rootShape = reqSchema === undefined ? undefined : resolveRootRef(reqSchema);
             const enveloped = rootShape !== undefined && !("$ref" in rootShape) && !("type" in rootShape && rootShape.type === "object");
             const transport = reqSchema === undefined ? undefined : enveloped ? envelope(reqSchema) : reqSchema;
-            const system = enveloped ? baseSystem + ENVELOPE_NOTE : baseSystem;
+            // structuredOutputs: false — the schema goes into the system turn instead of the wire field
+            const enforce = options.structuredOutputs !== false;
+            const system = (enveloped ? baseSystem + ENVELOPE_NOTE : baseSystem) + (!enforce && transport ? schemaNote(transport) : "");
+            const sent = { system, messages };
             const body = {
                 model,
                 max_tokens: maxTokens,
                 system,
                 messages,
             };
-            if (transport) {
+            if (transport && enforce) {
                 body.output_config = { format: { type: "json_schema", schema: transport } };
             }
             const res = await doFetch(`${baseUrl}/v1/messages`, {
@@ -52,7 +56,7 @@ export function anthropic(optionsOrModel) {
             const content = textBlock.text;
             const durationMs = Date.now() - requestedAt;
             if (!reqSchema)
-                return { text: content, durationMs };
+                return { text: content, durationMs, sent };
             let parsed;
             try {
                 parsed = JSON.parse(content);
@@ -61,7 +65,7 @@ export function anthropic(optionsOrModel) {
                 throw new NolaProviderError("Anthropic returned non-JSON despite structured outputs.", { cause: e });
             }
             const value = enveloped ? parsed.value : parsed;
-            return { text: JSON.stringify(value), durationMs };
+            return { text: JSON.stringify(value), durationMs, sent };
         },
     };
 }

package/dist/combinators.d.ts

@@ -25,7 +25,7 @@ export declare function isDefinitiveProviderError(error: unknown): boolean;
  * with no delay) ignores the header entirely. Distinct from the intent method
  * `.withRetry(n)`, which flat-retries the entire ask (composition, provider
  * call, parse, validation) with no backoff and no definitive-error check.
- * Mirrors the inner's dialect and decision brand.
+ * Forwards `infer` and carries the inner's decision brand.
  */
 export declare function withRetry(provider: LanguageModel, policy: RetryPolicy): LanguageModel;
 export declare function fallback(providers: LanguageModel[]): LanguageModel;

package/dist/combinators.js

@@ -1,6 +1,7 @@
 import { Codes } from "@nola-lang/ast";
-import { DECISION_MODEL, isDecisionModel, isInferModel, isPlatformModel, NolaConfigError, NolaProviderError } from "@nola-lang/core";
-import { callModel, isDecisionRequest } from "./dialect.js";
+import { DECISION_MODEL, isDecisionModel, isPlatformModel, NolaConfigError, NolaProviderError } from "@nola-lang/core";
+import { isDecisionRequest } from "./decision-request.js";
+import { requireInfer } from "./require-infer.js";
 export function constant(opts) {
     const delayMs = opts.delayMs ?? 0;
     return { maxRetries: opts.maxRetries, delayMs, multiplier: 1, maxDelayMs: delayMs };
@@ -45,18 +46,10 @@ function rejectPlatformModel(models, combinator) {
 function describeError(error) {
     return error instanceof Error ? error.message : String(error);
 }
-/**
- * Build the outer model of a combinator (decision types spec 2026-09-18
- * §6.1–6.2): infer-dialect iff any inner is (chat inners get the rendering
- * through callModel), branded a decision model iff any inner is. `run`
- * receives the request in the outer dialect.
- */
+/** Build the outer model of a combinator: branded a decision model iff any inner is; `run` receives the request as is. */
 function outer(name, inners, run) {
     const brand = inners.some((m) => isDecisionModel(m)) ? { [DECISION_MODEL]: true } : {};
-    const model = inners.some((m) => isInferModel(m))
-        ? { name, ...brand, infer: (req) => run(req) }
-        : { name, ...brand, complete: (req) => run(req) };
-    return model;
+    return { name, ...brand, infer: (req) => run(req) };
 }
 /**
  * Wire-level retry: re-attempts the single provider call with backoff,
@@ -66,9 +59,10 @@ function outer(name, inners, run) {
  * with no delay) ignores the header entirely. Distinct from the intent method
  * `.withRetry(n)`, which flat-retries the entire ask (composition, provider
  * call, parse, validation) with no backoff and no definitive-error check.
- * Mirrors the inner's dialect and decision brand.
+ * Forwards `infer` and carries the inner's decision brand.
  */
 export function withRetry(provider, policy) {
+    requireInfer([provider], "withRetry");
     rejectPlatformModel([provider], "withRetry");
     const inner = provider;
     return outer(`retry(${provider.name})`, [inner], async (req) => {
@@ -76,7 +70,7 @@ export function withRetry(provider, policy) {
         let lastError;
         for (let attempt = 0; attempt <= policy.maxRetries; attempt++) {
             try {
-                return await callModel(inner, req);
+                return await inner.infer(req);
             }
             catch (error) {
                 lastError = error;
@@ -100,7 +94,7 @@ async function tryInOrder(name, ordered, req) {
             continue;
         }
         try {
-            return await callModel(p, req);
+            return await p.infer(req);
         }
         catch (error) {
             failures.push(`${p.name}: ${describeError(error)}`);
@@ -110,6 +104,7 @@ async function tryInOrder(name, ordered, req) {
 }
 export function fallback(providers) {
     requireModels(providers, "fallback");
+    requireInfer(providers, "fallback");
     rejectPlatformModel(providers, "fallback");
     const inners = providers;
     const name = `fallback(${providers.map((p) => p.name).join(", ")})`;
@@ -117,6 +112,7 @@ export function fallback(providers) {
 }
 export function roundRobin(providers) {
     requireModels(providers, "roundRobin");
+    requireInfer(providers, "roundRobin");
     rejectPlatformModel(providers, "roundRobin");
     const inners = providers;
     const name = `roundRobin(${providers.map((p) => p.name).join(", ")})`;

package/dist/decision-request.d.ts

@@ -0,0 +1,4 @@
+import type { InferRequest } from "@nola-lang/core";
+/** True when the request's output schema carries a decision question (Choice / Scale / Prob). */
+export declare function isDecisionRequest(req: InferRequest): boolean;
+//# sourceMappingURL=decision-request.d.ts.map

package/dist/decision-request.js

@@ -0,0 +1,7 @@
+import { findDecisionQuestions } from "@nola-lang/core";
+/** True when the request's output schema carries a decision question (Choice / Scale / Prob). */
+export function isDecisionRequest(req) {
+    const output = req.intent.output;
+    return output.syntax === "json" && findDecisionQuestions(output.schema).length > 0;
+}
+//# sourceMappingURL=decision-request.js.map

package/dist/decisions.js

@@ -26,12 +26,12 @@ function contextualState(model) {
     }
     return any ? state : undefined;
 }
-const askText = (model) => model.input.text ?? model.input.instruction;
-/** What the model says about the ask, outer→inner: system, each scope's text, then (optionally) the ask text. */
+const askText = (model) => model.input.instruction;
+/** What the model says about the ask, outer→inner: system, each scope's instruction, then (optionally) the ask text. */
 function contextText(model, includeAskText) {
     const parts = [
         model.system ?? "",
-        ...scopesOuterFirst(model.scope).map((s) => s.text ?? s.instruction),
+        ...scopesOuterFirst(model.scope).map((s) => s.instruction),
         includeAskText ? askText(model) : "",
     ];
     return parts.filter((p) => p.trim() !== "").reduce((acc, p) => joinBlocks(acc, p), "");

package/dist/google.d.ts

@@ -7,6 +7,12 @@ export interface GoogleOptions {
     model: string;
     baseUrl?: string;
     fetch?: typeof globalThis.fetch;
+    /**
+     * Default true: the schema rides the API's structured-output field. false:
+     * nothing is sent on the wire and the schema is rendered into the system
+     * turn as a <schema> block — for a proxy or server that cannot enforce it.
+     */
+    structuredOutputs?: boolean;
 }
 /** A bare model string is shorthand for `{ model }` — every other option defaulted. */
 export declare function google(optionsOrModel: GoogleOptions | string): LanguageModel;

package/dist/google.js

@@ -1,5 +1,5 @@
-import { NolaProviderError, parseRetryAfter } from "@nola-lang/core";
-import { ENVELOPE_NOTE, envelope, resolveRootRef } from "./wire.js";
+import { NolaProviderError, parseRetryAfter, renderPrompt } from "@nola-lang/core";
+import { ENVELOPE_NOTE, envelope, resolveRootRef, schemaNote } from "./wire.js";
 /** A bare model string is shorthand for `{ model }` — every other option defaulted. */
 export function google(optionsOrModel) {
     const options = typeof optionsOrModel === "string" ? { model: optionsOrModel } : optionsOrModel;
@@ -8,19 +8,23 @@ export function google(optionsOrModel) {
     const model = options.model;
     return {
         name: "google",
-        async complete(req) {
+        async infer(req) {
             const requestedAt = Date.now();
             const envName = options.apiKeyEnv ?? "GEMINI_API_KEY";
             const apiKey = options.apiKey ?? process.env[envName];
             if (!apiKey) {
                 throw new NolaProviderError(`Google API key not found: environment variable ${envName} is not set (checked process.env, including the project .env applied by the Nola loader) and no \`apiKey\` was passed to google(). Fix: set ${envName}, or pass google({ apiKeyEnv: "MY_VAR" }) or google({ apiKey }) in nola.config.ts.`, { definitive: true });
             }
-            const { system: baseSystem, messages, output } = req.payload;
+            const { system: baseSystem, messages } = renderPrompt(req.intent);
+            const output = req.intent.output;
             const reqSchema = output.syntax === "json" ? output.schema : undefined;
             const rootShape = reqSchema === undefined ? undefined : resolveRootRef(reqSchema);
             const enveloped = rootShape !== undefined && !("$ref" in rootShape) && !("type" in rootShape && rootShape.type === "object");
             const transport = reqSchema === undefined ? undefined : enveloped ? envelope(reqSchema) : reqSchema;
-            const system = enveloped ? baseSystem + ENVELOPE_NOTE : baseSystem;
+            // structuredOutputs: false — the schema goes into the system turn instead of the wire field
+            const enforce = options.structuredOutputs !== false;
+            const system = (enveloped ? baseSystem + ENVELOPE_NOTE : baseSystem) + (!enforce && transport ? schemaNote(transport) : "");
+            const sent = { system, messages };
             const body = {
                 system_instruction: { parts: [{ text: system }] },
                 contents: messages.map((m) => ({
@@ -28,7 +32,7 @@ export function google(optionsOrModel) {
                     parts: [{ text: m.content }],
                 })),
             };
-            if (transport) {
+            if (transport && enforce) {
                 body.generationConfig = { responseMimeType: "application/json", responseJsonSchema: transport };
             }
             const res = await doFetch(`${baseUrl}/v1beta/models/${model}:generateContent`, {
@@ -51,7 +55,7 @@ export function google(optionsOrModel) {
             const content = part.text;
             const durationMs = Date.now() - requestedAt;
             if (!reqSchema)
-                return { text: content, durationMs };
+                return { text: content, durationMs, sent };
             let parsed;
             try {
                 parsed = JSON.parse(content);
@@ -60,7 +64,7 @@ export function google(optionsOrModel) {
                 throw new NolaProviderError("Google returned non-JSON despite structured output.", { cause: e });
             }
             const value = enveloped ? parsed.value : parsed;
-            return { text: JSON.stringify(value), durationMs };
+            return { text: JSON.stringify(value), durationMs, sent };
         },
     };
 }

package/dist/index.d.ts

@@ -3,9 +3,10 @@ import { google } from "./google.js";
 import { mockProvider } from "./mock.js";
 import { openai } from "./openai.js";
 import { typesafe } from "./typesafe.js";
+export { DEFAULT_SYSTEM, type InferRequest, type InferResult, type RenderedPrompt, renderPrompt } from "@nola-lang/core";
 export { type AnthropicOptions, anthropic } from "./anthropic.js";
 export { constant, exponential, fallback, isDefinitiveProviderError, type RetryPolicy, roundRobin, withRetry, } from "./combinators.js";
-export { callModel, isDecisionRequest, toClassic } from "./dialect.js";
+export { isDecisionRequest } from "./decision-request.js";
 export { type GoogleOptions, google } from "./google.js";
 export { type MockOptions, type MockRequest, mockProvider } from "./mock.js";
 export { type OpenAiOptions, openai } from "./openai.js";

package/dist/index.js

@@ -3,9 +3,10 @@ import { google } from "./google.js";
 import { mockProvider } from "./mock.js";
 import { openai } from "./openai.js";
 import { typesafe } from "./typesafe.js";
+export { DEFAULT_SYSTEM, renderPrompt } from "@nola-lang/core";
 export { anthropic } from "./anthropic.js";
 export { constant, exponential, fallback, isDefinitiveProviderError, roundRobin, withRetry, } from "./combinators.js";
-export { callModel, isDecisionRequest, toClassic } from "./dialect.js";
+export { isDecisionRequest } from "./decision-request.js";
 export { google } from "./google.js";
 export { mockProvider } from "./mock.js";
 export { openai } from "./openai.js";

package/dist/mock.d.ts

@@ -1,6 +1,8 @@
-import type { LanguageModel, ProviderRequest } from "@nola-lang/core";
-/** What a mock callback sees: the classic request — `payload` IS the rendering (reshape 2026-09-01). */
-export type MockRequest = ProviderRequest;
+import type { InferRequest, LanguageModel, RenderedPrompt } from "@nola-lang/core";
+/** What a mock callback sees: the intent, plus its default rendering on demand. */
+export type MockRequest = InferRequest & {
+    readonly prompt: RenderedPrompt;
+};
 export interface MockOptions {
     /**
      * Brand the mock a decision model (decision types spec 2026-09-18 §6.1): a

package/dist/mock.js

@@ -1,10 +1,18 @@
-import { DECISION_MODEL } from "@nola-lang/core";
+import { DECISION_MODEL, renderPrompt } from "@nola-lang/core";
+/** The request with a memoized `prompt` getter — rendered only when a callback reads it. */
+function withPrompt(req) {
+    let rendered;
+    return Object.defineProperty({ ...req }, "prompt", {
+        enumerable: false,
+        get: () => (rendered ??= renderPrompt(req.intent)),
+    });
+}
 export function mockProvider(source, options = {}) {
     const queue = Array.isArray(source) ? [...source] : null;
     return {
         ...(options.decisions ? { [DECISION_MODEL]: true } : {}),
         name: "mock",
-        async complete(req) {
+        async infer(req) {
             let value;
             if (queue) {
                 if (queue.length === 0)
@@ -12,7 +20,7 @@ export function mockProvider(source, options = {}) {
                 value = queue.shift();
             }
             else {
-                value = source(req);
+                value = source(withPrompt(req));
             }
             return { text: JSON.stringify(value) };
         },

package/dist/openai.d.ts

@@ -7,6 +7,13 @@ export interface OpenAiOptions {
     model: string;
     baseUrl?: string;
     fetch?: typeof globalThis.fetch;
+    /**
+     * Default true: the schema rides the API's structured-output field. false:
+     * nothing is sent on the wire and the schema is rendered into the system
+     * turn as a <schema> block — for OpenAI-compatible servers that ignore or
+     * reject json_schema.
+     */
+    structuredOutputs?: boolean;
 }
 /** A bare model string is shorthand for `{ model }` — every other option defaulted. */
 export declare function openai(optionsOrModel: OpenAiOptions | string): LanguageModel;

package/dist/openai.js

@@ -1,5 +1,23 @@
-import { NolaProviderError, parseRetryAfter } from "@nola-lang/core";
-import { ENVELOPE_NOTE, envelope, resolveRootRef } from "./wire.js";
+import { NolaProviderError, parseRetryAfter, renderPrompt } from "@nola-lang/core";
+import { ENVELOPE_NOTE, envelope, resolveRootRef, schemaNote } from "./wire.js";
+/**
+ * Keywords OpenAI's strict mode accepts beside type/enum/structure (its
+ * "supported properties" list); anything else is dropped. `format` is
+ * forwarded only for the values that list names — an unknown format value is
+ * a 400 from the API. minLength/maxLength are NOT forwarded: unverified.
+ */
+const STRING_KEYWORDS = ["pattern"];
+const OPENAI_FORMATS = new Set(["date-time", "time", "date", "duration", "email", "hostname", "ipv4", "ipv6", "uuid"]);
+const NUMBER_KEYWORDS = ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"];
+const ARRAY_KEYWORDS = ["minItems", "maxItems"];
+function pick(schema, keys) {
+    const out = {};
+    const s = schema;
+    for (const k of keys)
+        if (s[k] !== undefined)
+            out[k] = s[k];
+    return out;
+}
 /** Strict mode requires every property required; optionals become anyOf [T, null]. */
 function toStrict(schema) {
     const out = toStrictNode(schema);
@@ -17,18 +35,22 @@ function toStrict(schema) {
 function toStrictNode(schema) {
     if ("$ref" in schema)
         return { $ref: schema.$ref };
+    // JSDoc descriptions ride every node: since the prompt no longer carries the
+    // schema text (prompt-rendering spec 2026-09-28), the wire schema is the only
+    // channel a property's description has to the model.
+    const described = "description" in schema && schema.description !== undefined ? { description: schema.description } : {};
     // emit 15 shapes: choice passes through; strict mode accepts anyOf.
     // A literal keeps its `const` but gains the `type` it implies: OpenAI-compatible
     // backends (Cerebras) reject a bare `{ const }` node as an unsupported field,
     // and every backend accepts the typed form (it is a strict subset).
     if ("anyOf" in schema)
-        return { anyOf: schema.anyOf.map(toStrictNode) };
+        return { ...described, anyOf: schema.anyOf.map(toStrictNode) };
     if ("const" in schema)
-        return { type: typeof schema.const, const: schema.const };
+        return { ...described, type: typeof schema.const, const: schema.const };
     switch (schema.type) {
         case "object": {
             if (!("properties" in schema)) {
-                return { type: "object", additionalProperties: toStrictNode(schema.additionalProperties) };
+                return { ...described, type: "object", additionalProperties: toStrictNode(schema.additionalProperties) };
             }
             const properties = {};
             for (const [key, prop] of Object.entries(schema.properties)) {
@@ -36,6 +58,7 @@ function toStrictNode(schema) {
                 properties[key] = schema.required.includes(key) ? strict : { anyOf: [strict, { type: "null" }] };
             }
             return {
+                ...described,
                 type: "object",
                 properties,
                 required: Object.keys(schema.properties),
@@ -45,6 +68,7 @@ function toStrictNode(schema) {
         case "array":
             if ("prefixItems" in schema) {
                 return {
+                    ...described,
                     type: "array",
                     prefixItems: schema.prefixItems.map(toStrictNode),
                     items: false,
@@ -52,13 +76,22 @@ function toStrictNode(schema) {
                     maxItems: schema.maxItems,
                 };
             }
-            return { type: "array", items: toStrictNode(schema.items) };
+            return { ...described, type: "array", items: toStrictNode(schema.items), ...pick(schema, ARRAY_KEYWORDS) };
+        case "string":
+            return {
+                ...described,
+                type: "string",
+                ...(schema.enum ? { enum: [...schema.enum] } : {}),
+                ...pick(schema, STRING_KEYWORDS),
+                ...(schema.format !== undefined && OPENAI_FORMATS.has(schema.format) ? { format: schema.format } : {}),
+            };
+        case "number":
+        case "integer":
+            return { ...described, type: schema.type, ...pick(schema, NUMBER_KEYWORDS) };
         case "null":
             return { type: "null" };
         default:
-            return schema.type === "string" && schema.enum
-                ? { type: "string", enum: [...schema.enum] }
-                : { type: schema.type };
+            return { ...described, type: schema.type };
     }
 }
 /**
@@ -128,24 +161,28 @@ export function openai(optionsOrModel) {
     const model = options.model;
     return {
         name: "openai",
-        async complete(req) {
+        async infer(req) {
             const requestedAt = Date.now();
             const envName = options.apiKeyEnv ?? "OPENAI_API_KEY";
             const apiKey = options.apiKey ?? process.env[envName];
             if (!apiKey) {
                 throw new NolaProviderError(`OpenAI API key not found: environment variable ${envName} is not set (checked process.env, including the project .env applied by the Nola loader) and no \`apiKey\` was passed to openai(). Fix: set ${envName}, or pass openai({ apiKeyEnv: "MY_VAR" }) or openai({ apiKey }) in nola.config.ts.`, { definitive: true });
             }
-            const { system: baseSystem, messages, output } = req.payload;
+            const { system: baseSystem, messages } = renderPrompt(req.intent);
+            const output = req.intent.output;
             const reqSchema = output.syntax === "json" ? output.schema : undefined;
             const rootShape = reqSchema === undefined ? undefined : resolveRootRef(reqSchema);
             const enveloped = rootShape !== undefined && !("$ref" in rootShape) && !("type" in rootShape && rootShape.type === "object");
             const transport = reqSchema === undefined ? undefined : enveloped ? envelope(reqSchema) : reqSchema;
-            const system = enveloped ? baseSystem + ENVELOPE_NOTE : baseSystem;
+            // structuredOutputs: false — the schema goes into the system turn instead of the wire field
+            const enforce = options.structuredOutputs !== false;
+            const system = (enveloped ? baseSystem + ENVELOPE_NOTE : baseSystem) + (!enforce && transport ? schemaNote(transport) : "");
+            const sent = { system, messages };
             const body = {
                 model,
                 messages: [{ role: "system", content: system }, ...messages],
             };
-            if (transport) {
+            if (transport && enforce) {
                 body.response_format = {
                     type: "json_schema",
                     json_schema: { name: "nola_extraction", strict: true, schema: toStrict(transport) },
@@ -162,7 +199,7 @@ export function openai(optionsOrModel) {
                 if (reqSchema !== undefined) {
                     const recovered = recoverFailedGeneration(errorBody, enveloped, reqSchema);
                     if (recovered !== undefined)
-                        return { text: recovered };
+                        return { text: recovered, sent };
                 }
                 throw new NolaProviderError(`OpenAI request failed: ${res.status} ${res.statusText} — ${errorBody.slice(0, 500)}`, {
                     status: res.status,
@@ -174,7 +211,7 @@ export function openai(optionsOrModel) {
             if (typeof content !== "string")
                 throw new NolaProviderError("OpenAI response had no message content.");
             if (!reqSchema)
-                return { text: content };
+                return { text: content, sent };
             let parsed;
             try {
                 parsed = JSON.parse(content);
@@ -184,7 +221,7 @@ export function openai(optionsOrModel) {
             }
             const value = enveloped ? parsed.value : parsed;
             const durationMs = Date.now() - requestedAt;
-            return { text: JSON.stringify(fromStrict(value, reqSchema)), durationMs };
+            return { text: JSON.stringify(fromStrict(value, reqSchema)), durationMs, sent };
         },
     };
 }

package/dist/record-replay.d.ts

@@ -3,10 +3,9 @@ import type { LanguageModel, PlatformModel } from "@nola-lang/core";
  * Pass-through provider that appends `{ fingerprint, request, response }` JSONL
  * entries. The fingerprint is computed from the RAW request (so replay-time
  * lookups match) and is never redacted; persisted content strings are. The
- * payload is stored as sent — the classic rendering for a chat provider, the
- * model for the platform model — and `record` MIRRORS the inner kind
- * (platform-config design 2026-09-03): a platform inner yields a branded
- * platform model exposing infer; record(openai()) exposes complete.
+ * ledger stores the INTENT (the ask as data, never a rendering), and `record`
+ * carries the inner's brands: a platform inner yields a branded platform
+ * model, a decision inner a decision model.
  */
 export declare function record(inner: PlatformModel, ledgerPath: string): PlatformModel;
 export declare function record(inner: LanguageModel, ledgerPath: string): LanguageModel;
@@ -14,17 +13,17 @@ export declare function record(inner: LanguageModel, ledgerPath: string): Langua
  * Offline provider serving recorded responses by request fingerprint. Strict:
  * an unrecorded request is a definitive error, never a silent live call.
  *
- * A fingerprint is computed over the classic rendering as first composed —
- * whichever payload shape arrives (see `fingerprintRequest`) — so a ledger
- * recorded through any provider replays for any other, and one ask's first
- * attempt and its correction retry hash identically — a recorded correction pair appends TWO
- * ledger lines under the SAME key. Entries are served FIFO per fingerprint:
- * each `complete()` shifts the next recorded response off that key's queue,
- * so a replayed session reproduces the correction turn instead of jumping
- * straight to the corrected answer. Once only one entry remains for a key it
- * keeps serving that last one — a single-entry key (the common case) behaves
- * exactly as a plain map lookup, and repeat asks beyond what was recorded
- * still get an answer instead of failing.
+ * A fingerprint is computed over the intent as first composed (see
+ * `fingerprintRequest`), so a ledger recorded through any provider replays
+ * for any other, and one ask's first attempt and its correction retry hash
+ * identically — a recorded correction pair appends TWO ledger lines under
+ * the SAME key. Entries are served FIFO per fingerprint: each `infer()`
+ * shifts the next recorded response off that key's queue, so a replayed
+ * session reproduces the correction turn instead of jumping straight to the
+ * corrected answer. Once only one entry remains for a key it keeps serving
+ * that last one — a single-entry key (the common case) behaves exactly as a
+ * plain map lookup, and repeat asks beyond what was recorded still get an
+ * answer instead of failing.
  */
 export declare function replay(ledgerPath: string): LanguageModel;
 //# sourceMappingURL=record-replay.d.ts.map

package/dist/record-replay.js

@@ -1,41 +1,21 @@
 import { appendFileSync, readFileSync } from "node:fs";
 import { Codes } from "@nola-lang/ast";
-import { DECISION_MODEL, fingerprintRequest, isDecisionModel, isInferModel, isPlatformModel, NolaConfigError, NolaProviderError, PLATFORM_MODEL, redactDeep, redactSecrets, } from "@nola-lang/core";
+import { DECISION_MODEL, fingerprintRequest, isDecisionModel, isPlatformModel, NolaConfigError, NolaProviderError, PLATFORM_MODEL, redactDeep, redactSecrets, } from "@nola-lang/core";
+import { requireInfer } from "./require-infer.js";
 export function record(inner, ledgerPath) {
-    // the brands ride along: the platform's (its own rules) and the decision capability
+    requireInfer([inner], "record");
     const brands = {
         ...(isPlatformModel(inner) ? { [PLATFORM_MODEL]: true } : {}),
         ...(isDecisionModel(inner) ? { [DECISION_MODEL]: true } : {}),
     };
-    if (isInferModel(inner)) {
-        return {
-            ...brands,
-            name: `record(${inner.name})`,
-            async infer(req) {
-                const res = await inner.infer(req);
-                const entry = {
-                    fingerprint: fingerprintRequest({
-                        payload: req.model,
-                        ...(req.params ? { params: req.params } : {}),
-                        ...(req.profile !== undefined ? { profile: req.profile } : {}),
-                    }),
-                    request: { payload: redactDeep(req.model), ...(req.params ? { params: req.params } : {}) },
-                    response: { text: redactSecrets(res.text) },
-                };
-                appendFileSync(ledgerPath, `${JSON.stringify(entry)}\n`, "utf8");
-                return res;
-            },
-        };
-    }
-    const chat = inner;
     return {
         ...brands,
         name: `record(${inner.name})`,
-        async complete(req) {
-            const res = await chat.complete(req);
+        async infer(req) {
+            const res = await inner.infer(req);
             const entry = {
                 fingerprint: fingerprintRequest(req),
-                request: { payload: redactDeep(req.payload), ...(req.params ? { params: req.params } : {}) },
+                request: { intent: redactDeep(req.intent), ...(req.params ? { params: req.params } : {}) },
                 response: { text: redactSecrets(res.text) },
             };
             appendFileSync(ledgerPath, `${JSON.stringify(entry)}\n`, "utf8");
@@ -47,17 +27,17 @@ export function record(inner, ledgerPath) {
  * Offline provider serving recorded responses by request fingerprint. Strict:
  * an unrecorded request is a definitive error, never a silent live call.
  *
- * A fingerprint is computed over the classic rendering as first composed —
- * whichever payload shape arrives (see `fingerprintRequest`) — so a ledger
- * recorded through any provider replays for any other, and one ask's first
- * attempt and its correction retry hash identically — a recorded correction pair appends TWO
- * ledger lines under the SAME key. Entries are served FIFO per fingerprint:
- * each `complete()` shifts the next recorded response off that key's queue,
- * so a replayed session reproduces the correction turn instead of jumping
- * straight to the corrected answer. Once only one entry remains for a key it
- * keeps serving that last one — a single-entry key (the common case) behaves
- * exactly as a plain map lookup, and repeat asks beyond what was recorded
- * still get an answer instead of failing.
+ * A fingerprint is computed over the intent as first composed (see
+ * `fingerprintRequest`), so a ledger recorded through any provider replays
+ * for any other, and one ask's first attempt and its correction retry hash
+ * identically — a recorded correction pair appends TWO ledger lines under
+ * the SAME key. Entries are served FIFO per fingerprint: each `infer()`
+ * shifts the next recorded response off that key's queue, so a replayed
+ * session reproduces the correction turn instead of jumping straight to the
+ * corrected answer. Once only one entry remains for a key it keeps serving
+ * that last one — a single-entry key (the common case) behaves exactly as a
+ * plain map lookup, and repeat asks beyond what was recorded still get an
+ * answer instead of failing.
  */
 export function replay(ledgerPath) {
     let raw;
@@ -93,7 +73,7 @@ export function replay(ledgerPath) {
         // a ledger serves whatever it holds — a replayed decision ask needs no live capability
         ...{ [DECISION_MODEL]: true },
         name: "replay",
-        async complete(req) {
+        async infer(req) {
             const fingerprint = fingerprintRequest(req);
             const queue = entries.get(fingerprint);
             if (!queue || queue.length === 0) {

package/dist/require-infer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Every model a combinator (or `record`) wraps must speak the one dialect —
+ * `infer(req)`. A `complete`-only inner is the retired chat form and gets the
+ * same NOLA3003 migration message the config resolver gives a root model;
+ * anything else is not a model. Checked at construction so the failure is
+ * a config error, never a TypeError at the first ask (prompt-rendering spec
+ * 2026-09-28 §3.10).
+ */
+export declare function requireInfer(models: readonly unknown[], where: string): void;
+//# sourceMappingURL=require-infer.d.ts.map

package/dist/require-infer.js

@@ -0,0 +1,23 @@
+import { Codes } from "@nola-lang/ast";
+import { NolaConfigError } from "@nola-lang/core";
+/**
+ * Every model a combinator (or `record`) wraps must speak the one dialect —
+ * `infer(req)`. A `complete`-only inner is the retired chat form and gets the
+ * same NOLA3003 migration message the config resolver gives a root model;
+ * anything else is not a model. Checked at construction so the failure is
+ * a config error, never a TypeError at the first ask (prompt-rendering spec
+ * 2026-09-28 §3.10).
+ */
+export function requireInfer(models, where) {
+    for (const m of models) {
+        const o = m;
+        if (o && typeof o === "object" && typeof o.infer === "function")
+            continue;
+        const name = o && typeof o === "object" && typeof o.name === "string" ? o.name : String(m);
+        if (o && typeof o === "object" && typeof o.complete === "function") {
+            throw new NolaConfigError(`${where}(${name}) implements complete(req) — a model implements infer(req) and receives the InferenceModel; render it with renderPrompt() from @nola-lang/providers and return { text, sent }.`, Codes.ConfigInvalid);
+        }
+        throw new NolaConfigError(`${where}(${name}) is not a model (need { name: string, infer(req) }).`, Codes.ConfigInvalid);
+    }
+}
+//# sourceMappingURL=require-infer.js.map

package/dist/typesafe.js

@@ -36,9 +36,9 @@ export function typesafe(optionsOrModel) {
             }
             const askThreshold = req.params?.providerOptions?.threshold;
             const threshold = typeof askThreshold === "number" ? askThreshold : (options.threshold ?? DEFAULT_THRESHOLD);
-            // Jev has no conversation: a correction turn (req.model.correction) has
+            // Jev has no conversation: a correction turn (req.intent.correction) has
             // nothing to say to it, so the ask is re-answered from the same state.
-            const mapped = planFor(req.model, { threshold });
+            const mapped = planFor(req.intent, { threshold });
             if (!mapped.ok) {
                 throw new NolaProviderError(`TypeSafe cannot serve this ask: ${mapped.reason}`, { definitive: true });
             }

package/dist/wire.d.ts

@@ -1,5 +1,7 @@
 import type { JsonSchema } from "@nola-lang/core";
-export declare const ENVELOPE_NOTE = " Because the response schema is wrapped, reply with a JSON object of the form {\"value\": X} where X is the value that conforms to responseSchema.";
+export declare const ENVELOPE_NOTE = " Reply with a JSON object of the form {\"value\": X}, where X is the requested value.";
+/** The schema rendered into the system turn for a backend that cannot enforce it (`structuredOutputs: false`). */
+export declare function schemaNote(schema: JsonSchema): string;
 /** Follow root-level $ref chains so the envelope decision sees the real shape. */
 export declare function resolveRootRef(schema: JsonSchema): JsonSchema;
 /** Wrap a non-object schema in the {value} envelope, hoisting $defs to the new root. */

package/dist/wire.js

@@ -1,8 +1,12 @@
 // When a scalar/array schema is wrapped in the {value} envelope, the schema
 // constraint alone only binds providers that do constrained decoding.
-// Generate-then-validate backends follow the prompt, so the prompt must ask
+// Generate-then-validate backends follow the prompt, so the system turn asks
 // for the envelope too.
-export const ENVELOPE_NOTE = ' Because the response schema is wrapped, reply with a JSON object of the form {"value": X} where X is the value that conforms to responseSchema.';
+export const ENVELOPE_NOTE = ' Reply with a JSON object of the form {"value": X}, where X is the requested value.';
+/** The schema rendered into the system turn for a backend that cannot enforce it (`structuredOutputs: false`). */
+export function schemaNote(schema) {
+    return `\n\n<schema>\n${JSON.stringify(schema)}\n</schema>\nReply with a single JSON value conforming to the schema.`;
+}
 /** Follow root-level $ref chains so the envelope decision sees the real shape. */
 export function resolveRootRef(schema) {
     let current = schema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nola-lang/providers",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Nola bring-your-own LLM providers: openai, anthropic, google, typesafe, mock, resilience combinators, record/replay",
   "keywords": [
     "nola",
@@ -37,8 +37,8 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@nola-lang/ast": "0.1.12",
-    "@nola-lang/core": "0.1.12"
+    "@nola-lang/ast": "0.1.14",
+    "@nola-lang/core": "0.1.14"
   },
   "engines": {
     "node": ">=22"

package/dist/dialect.d.ts

@@ -1,12 +0,0 @@
-import type { ChatModel, InferModel, InferRequest, ProviderRequest, ProviderResponse } from "@nola-lang/core";
-/**
- * The dialect bridge (decision types spec 2026-09-18 §6.2): a combinator is
- * infer-dialect iff any inner is, and renders for its chat inners. `callModel`
- * is the one place that decides which method an inner gets.
- */
-export declare function callModel(model: ChatModel | InferModel, req: InferRequest | ProviderRequest): Promise<ProviderResponse>;
-/** An infer request rendered for a chat inner: the rendering replaces the model; everything else rides along. */
-export declare function toClassic(req: InferRequest): ProviderRequest;
-/** True when the request's output schema carries a decision question (either request shape). */
-export declare function isDecisionRequest(req: InferRequest | ProviderRequest): boolean;
-//# sourceMappingURL=dialect.d.ts.map

package/dist/dialect.js

@@ -1,25 +0,0 @@
-import { findDecisionQuestions, isInferModel, NolaProviderError, renderClassic } from "@nola-lang/core";
-/**
- * The dialect bridge (decision types spec 2026-09-18 §6.2): a combinator is
- * infer-dialect iff any inner is, and renders for its chat inners. `callModel`
- * is the one place that decides which method an inner gets.
- */
-export async function callModel(model, req) {
-    if (isInferModel(model)) {
-        if ("model" in req)
-            return model.infer(req);
-        throw new NolaProviderError(`infer-dialect model "${model.name}" received a classic request — a combinator over it must expose infer()`, { definitive: true });
-    }
-    return model.complete("model" in req ? toClassic(req) : req);
-}
-/** An infer request rendered for a chat inner: the rendering replaces the model; everything else rides along. */
-export function toClassic(req) {
-    const { model, project: _project, ...rest } = req;
-    return { payload: renderClassic(model), ...rest };
-}
-/** True when the request's output schema carries a decision question (either request shape). */
-export function isDecisionRequest(req) {
-    const output = "model" in req ? req.model.output : req.payload.output;
-    return output.syntax === "json" && findDecisionQuestions(output.schema).length > 0;
-}
-//# sourceMappingURL=dialect.js.map