@smthrs/harness 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/StructuredOutput.d.ts

@@ -0,0 +1,252 @@
+/**
+ * Turning one agent's final text into a value the declared output schema
+ * accepts, or into a typed failure.
+ *
+ * A model may answer with a bare JSON document, prose wrapped around a JSON
+ * document, a fenced block, or JSON of the wrong shape. Downstream nodes must
+ * never receive that ambiguity, so this module implements the recovery
+ * contract in `../docs/concepts.md#structured-output`:
+ *
+ * 1. parse the complete, BOM-stripped response and decode it;
+ * 2. otherwise scan once for balanced JSON containers, take the container
+ *    whose matching close ends last, and decode that;
+ * 3. otherwise report a typed {@link StructuredOutputFailure} carrying bounded
+ *    diagnostics, which is what a caller re-prompts with when it still holds a
+ *    correction slot.
+ *
+ * Every candidate is decoded by the declared schema. Extraction never relaxes
+ * validation: it only decides which bytes are offered to it, and the schema may
+ * accept any JSON root rather than silently requiring an object.
+ *
+ * The prompt half is {@link instructions}. It renders the declared schema as a
+ * JSON Schema document placed in the run's system teaching, which is BAML's
+ * `ctx.output_format` injection reached through the seam the vault note
+ * specifies — the model is told the shape before it answers, and the answer is
+ * still validated locally. Provider acceptance is not a cast.
+ *
+ * Reference consulted: the `generateObject` function from Effect's
+ * `effect/unstable/ai/LanguageModel` module, which
+ * sends `responseFormat: { type: "json", schema }` and then decodes the result
+ * with the same schema, failing `AiError.InvalidOutputError` on mismatch. The
+ * decode-and-fail-typed half is copied. The provider `responseFormat` half is
+ * not reachable here: `@smthrs/model`'s `ModelRequest.GenerationParams` has no
+ * response-format field, and the cell loop's final answer is a `Cell.Complete`
+ * `output` string rather than a provider-decoded value, so the schema is
+ * carried in the prompt and enforced at this boundary.
+ *
+ * @since 0.1.0
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+/**
+ * Stable reasons a structured-output boundary failed.
+ *
+ * `invalid_json` means candidate text was not JSON. `schema_mismatch` means
+ * JSON parsed but the declared schema refused it. `no_candidate` means the
+ * answer contained no candidate text. `correction_exhausted` means the
+ * boundary had already spent its correction budget.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export declare const StructuredOutputFailureCode: Schema.Literals<readonly ["invalid_json", "schema_mismatch", "no_candidate", "correction_exhausted"]>;
+/**
+ * Stable reasons a structured-output boundary failed.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export type StructuredOutputFailureCode = typeof StructuredOutputFailureCode.Type;
+/**
+ * Stable reasons an individual structured-output issue was reported.
+ *
+ * `invalid_json` means candidate text was not JSON. `no_candidate` means the
+ * answer contained no candidate text. `invalid_type` means a decoded value had
+ * the wrong type. `invalid_value` means a value of the expected type was still
+ * invalid. `missing_key` means a required property was absent.
+ * `unexpected_key` means a prohibited extra property was present. `forbidden`
+ * means decoding attempted an operation the schema forbids. `one_of` means
+ * more than one exclusive union member matched. `constraint` means a schema
+ * check or empty-union fallback failed.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export declare const OutputIssueCode: Schema.Literals<readonly ["invalid_json", "no_candidate", "invalid_type", "invalid_value", "missing_key", "unexpected_key", "forbidden", "one_of", "constraint"]>;
+/**
+ * Stable reasons an individual structured-output issue was reported.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export type OutputIssueCode = typeof OutputIssueCode.Type;
+declare const OutputIssue_base: Schema.Class<OutputIssue, Schema.Struct<{
+    /** The stable reason this issue was reported. */
+    readonly code: Schema.Literals<readonly ["invalid_json", "no_candidate", "invalid_type", "invalid_value", "missing_key", "unexpected_key", "forbidden", "one_of", "constraint"]>;
+    /** The JSON path of the offending value, dot/bracket joined; empty for the root. */
+    readonly path: Schema.String;
+    /** What the decoder wanted there. */
+    readonly message: Schema.String;
+}>, {}>;
+/**
+ * One bounded issue raised while decoding structured output.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ * @slop
+ */
+export declare class OutputIssue extends OutputIssue_base {
+    /** Renders the issue for existing prose-oriented consumers. */
+    toString(): string;
+}
+declare const StructuredOutputFailure_base: Schema.Class<StructuredOutputFailure, Schema.TaggedStruct<"/harness/StructuredOutputFailure", {
+    /** The stable reason this boundary failed. */
+    readonly code: Schema.Literals<readonly ["invalid_json", "schema_mismatch", "no_candidate", "correction_exhausted"]>;
+    /** The declared output schema's canonical digest. */
+    readonly schema: Schema.String;
+    /** SHA-256 of the text the decoder was last offered. */
+    readonly candidate: Schema.String;
+    /** Correction attempts already spent on this boundary. */
+    readonly corrections: Schema.Number;
+    /** The correction budget the boundary was declared with. */
+    readonly limit: Schema.Number;
+    /** At most {@link maxIssues} structured validation issues. */
+    readonly issues: Schema.$Array<typeof OutputIssue>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The terminal failure of one structured-output boundary.
+ *
+ * It carries what an operator needs to tell two identical-looking refusals
+ * apart: which schema was demanded, how many correction slots the attempt
+ * consumed out of its budget, the digest of the last candidate that was
+ * offered to the decoder, and the bounded issue list.
+ *
+ * @category errors
+ * @since 0.1.0
+ * @slop
+ */
+export declare class StructuredOutputFailure extends StructuredOutputFailure_base {
+}
+/**
+ * The most validation issues a failure or a correction prompt carries.
+ *
+ * Bounded for the same reason smithers bounds its own validation summary: a
+ * wide struct that mismatched everywhere would otherwise spend the correction
+ * prompt's whole budget restating the schema back to the model.
+ *
+ * @category constants
+ * @since 0.1.0
+ * @slop
+ */
+export declare const maxIssues = 5;
+/**
+ * The JSON Schema document for a declared output schema.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export declare const jsonSchema: (schema: Schema.Top) => unknown;
+/**
+ * The canonical digest of a declared output schema.
+ *
+ * Two declarations that render the same JSON Schema name the same boundary, so
+ * this is what a step key folds in rather than the schema value itself.
+ *
+ * @category identity
+ * @since 0.1.0
+ * @slop
+ */
+export declare const digest: (schema: Schema.Top) => string;
+/**
+ * The system teaching that tells a run what its final `output` must be.
+ *
+ * Written against the cell contract: a cell finishes by calling
+ * `ctx.done(output)`, and the sandbox rejects a returned transition, so the
+ * instruction is about the argument of that call and not about the assistant
+ * message around it. The run passes the value itself: a structured value
+ * reaches {@link decode} as canonical JSON, and a string as its own text.
+ *
+ * @category prompts
+ * @since 0.1.0
+ * @slop
+ */
+export declare const instructions: (schema: Schema.Top) => string;
+/**
+ * The digest of one failure's rendered validation issues.
+ *
+ * Two rejections that raised the same issues share this digest, which is what a
+ * record carries instead of the issues themselves: a journal that repeated the
+ * validator's prose for every correction would grow with the model's verbosity,
+ * and what an operator actually asks is whether the second answer was wrong the
+ * same way as the first.
+ *
+ * @category identity
+ * @since 0.1.0
+ */
+export declare const issuesDigest: (failure: StructuredOutputFailure) => string;
+/**
+ * The correction teaching appended when a candidate failed to decode.
+ *
+ * It restates the schema and the bounded diagnostics and nothing else: a
+ * correction does not reinterpret the task, so the original prompt is repeated
+ * verbatim by the caller and only this section is new.
+ *
+ * @category prompts
+ * @since 0.1.0
+ * @slop
+ */
+export declare const correction: (failure: StructuredOutputFailure) => string;
+/**
+ * The balanced JSON container whose matching close ends last.
+ *
+ * Scans once, left to right, tracking object and array delimiters, quoted
+ * strings, and escapes. A mismatched close abandons the open container rather
+ * than pairing it with the wrong opener, so a truncated prefix cannot be
+ * reported as a complete document. `undefined` means the text holds no
+ * balanced container at all.
+ *
+ * This is the array-capable form of smithers' `extractLastBalancedJson`, which
+ * is object-only.
+ *
+ * @category extraction
+ * @since 0.1.0
+ * @slop
+ */
+export declare const lastBalanced: (text: string) => string | undefined;
+/**
+ * The candidates offered to the decoder, in the declared recovery order.
+ *
+ * @category extraction
+ * @since 0.1.0
+ * @slop
+ */
+export declare const candidates: (text: string) => ReadonlyArray<string>;
+/**
+ * Decodes one agent answer with the declared output schema.
+ *
+ * Decodes an original completion value first when supplied. Only a string
+ * refused for its type proceeds to legacy text extraction; refinements and
+ * nonstring failures retain the original value's diagnostics.
+ * Tries every {@link candidates} entry in order and returns the first the
+ * schema accepts, then the answer itself, untrimmed, as a string unless it is
+ * a JSON string literal, which is how a `ctx.done("text")` answer reaches a
+ * string schema. When none does, the failure reports the issues raised by the
+ * LAST candidate, which is the narrowest text the extractor could isolate and
+ * therefore the one a correction prompt should be about.
+ *
+ * @category decoding
+ * @since 0.1.0
+ * @slop
+ */
+export declare const decode: <S extends Schema.Top>(schema: S, text: string, attempt: {
+    readonly corrections: number;
+    readonly limit: number;
+}, value?: Schema.Json | undefined) => Effect.Effect<S["Type"], StructuredOutputFailure, S["DecodingServices"]>;
+export {};
+//# sourceMappingURL=StructuredOutput.d.ts.map

package/dist/cjs/StructuredOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructuredOutput.d.ts","sourceRoot":"","sources":["../../src/StructuredOutput.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAIH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,2BAA2B,uGAKtC,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAC,IAAI,CAAA;AAEjF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,mKAU1B,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;;IAUvD,iDAAiD;;IAEjD,oFAAoF;;IAEpF,qCAAqC;;;AAZvC;;;;;;GAMG;AACH,qBAAa,WAAY,SAAQ,gBAO/B;IACA,+DAA+D;IACtD,QAAQ,IAAI,MAAM;CAG5B;;IAiBG,8CAA8C;;IAE9C,qDAAqD;;IAErD,wDAAwD;;IAExD,0DAA0D;;IAE1D,4DAA4D;;IAE5D,8DAA8D;;;;AAzBlE;;;;;;;;;;;GAWG;AACH,qBAAa,uBAAwB,SAAQ,4BAiB5C;CAAG;AAIJ;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,IAAI,CAAA;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,MAAM,CAAC,GAAG,KAAG,OAK/C,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GAAI,QAAQ,MAAM,CAAC,GAAG,KAAG,MAA6D,CAAA;AAEzG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,CAAC,GAAG,KAAG,MAS3C,CAAA;AAEP;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,uBAAuB,KAAG,MAG7D,CAAA;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GAAI,SAAS,uBAAuB,KAAG,MAQJ,CAAA;AAI1D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,KAAG,MAAM,GAAG,SAqCpD,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,KAAG,aAAa,CAAC,MAAM,CAI7D,CAAA;AAqDD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,MAAM,CAAC,GAAG,EACzC,QAAQ,CAAC,EACT,MAAM,MAAM,EACZ,SAAS;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EACjE,QAAQ,MAAM,CAAC,IAAI,GAAG,SAAS,KAC9B,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,uBAAuB,EAAE,CAAC,CAAC,kBAAkB,CAAC,CA0EtE,CAAA"}

package/dist/cjs/StructuredOutput.js

@@ -0,0 +1,266 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var StructuredOutput_exports = {};
+__export(StructuredOutput_exports, {
+  OutputIssue: () => OutputIssue,
+  OutputIssueCode: () => OutputIssueCode,
+  StructuredOutputFailure: () => StructuredOutputFailure,
+  StructuredOutputFailureCode: () => StructuredOutputFailureCode,
+  candidates: () => candidates,
+  correction: () => correction,
+  decode: () => decode,
+  digest: () => digest,
+  instructions: () => instructions,
+  issuesDigest: () => issuesDigest,
+  jsonSchema: () => jsonSchema,
+  lastBalanced: () => lastBalanced,
+  maxIssues: () => maxIssues
+});
+module.exports = __toCommonJS(StructuredOutput_exports);
+var Digest = __toESM(require("@smthrs/core/Digest"), 1);
+var Fault = __toESM(require("@smthrs/flow/Fault"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var SchemaIssue = __toESM(require("effect/SchemaIssue"), 1);
+var elide = __toESM(require("./internal/elide.js"), 1);
+const StructuredOutputFailureCode = Schema.Literals([
+  "invalid_json",
+  "schema_mismatch",
+  "no_candidate",
+  "correction_exhausted"
+]);
+const OutputIssueCode = Schema.Literals([
+  "invalid_json",
+  "no_candidate",
+  "invalid_type",
+  "invalid_value",
+  "missing_key",
+  "unexpected_key",
+  "forbidden",
+  "one_of",
+  "constraint"
+]);
+class OutputIssue extends Schema.Class("flows/harness/StructuredOutput/OutputIssue")({
+  /** The stable reason this issue was reported. */
+  code: OutputIssueCode,
+  /** The JSON path of the offending value, dot/bracket joined; empty for the root. */
+  path: Schema.String,
+  /** What the decoder wanted there. */
+  message: Schema.String
+}) {
+  /** Renders the issue for existing prose-oriented consumers. */
+  toString() {
+    return this.path === "" ? this.message : `${this.path}: ${this.message}`;
+  }
+}
+class StructuredOutputFailure extends Schema.TaggedError()(
+  "/harness/StructuredOutputFailure",
+  {
+    /** The stable reason this boundary failed. */
+    code: StructuredOutputFailureCode,
+    /** The declared output schema's canonical digest. */
+    schema: Schema.String,
+    /** SHA-256 of the text the decoder was last offered. */
+    candidate: Schema.String,
+    /** Correction attempts already spent on this boundary. */
+    corrections: Schema.Number,
+    /** The correction budget the boundary was declared with. */
+    limit: Schema.Number,
+    /** At most {@link maxIssues} structured validation issues. */
+    issues: Schema.Array(OutputIssue),
+    message: Schema.String
+  }
+) {
+}
+Fault.register("/harness/StructuredOutputFailure", "dependency");
+const maxIssues = 5;
+const jsonSchema = (schema) => {
+  const document = Schema.toJsonSchemaDocument(schema, { onExcessProperty: "error" });
+  return Object.keys(document.definitions).length > 0 ? { ...document.schema, $defs: document.definitions } : document.schema;
+};
+const digest = (schema) => Digest.digest(Digest.canonical(jsonSchema(schema)));
+const instructions = (schema) => `## Required output shape
+
+Finish by calling \`ctx.done(output)\` with the value itself: a JavaScript
+value that validates against this JSON Schema, such as
+\`ctx.done({ ...fields })\`. Do not stringify it, and add no prose around it.
+
+\`\`\`json
+${JSON.stringify(jsonSchema(schema), null, 2)}
+\`\`\``;
+const issuesDigest = (failure) => Digest.digest(
+  Digest.canonical(failure.issues.map((issue) => ({ path: issue.path, message: issue.message })))
+);
+const correction = (failure) => `## Your previous answer did not validate
+
+The output you passed to \`ctx.done\` could not be decoded against the required
+schema. Call \`ctx.done(output)\` again with the same information as a value
+that validates.
+
+Validation issues:
+${failure.issues.map((issue) => `- ${issue}`).join("\n")}`;
+const stripBom = (text) => text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+const lastBalanced = (text) => {
+  const stack = [];
+  let start = -1;
+  let found = void 0;
+  let quoted2 = false;
+  let escaped = false;
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index];
+    if (quoted2) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') quoted2 = false;
+      continue;
+    }
+    if (char === '"') {
+      if (stack.length > 0) quoted2 = true;
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      if (stack.length === 0) start = index;
+      stack.push(char);
+      continue;
+    }
+    if (char === "}" || char === "]") {
+      const opener = stack.pop();
+      if (opener === void 0) continue;
+      if (char === "}" !== (opener === "{")) {
+        stack.length = 0;
+        start = -1;
+        continue;
+      }
+      if (stack.length === 0 && start >= 0) found = text.slice(start, index + 1);
+    }
+  }
+  return found;
+};
+const candidates = (text) => {
+  const stripped = stripBom(text).trim();
+  const balanced = lastBalanced(stripped);
+  return balanced === void 0 || balanced === stripped ? [stripped] : [stripped, balanced];
+};
+const issueMessage = (message) => elide.head(message, 240, "reissue the answer to see the whole issue");
+const issuePath = (path) => path.map(
+  (segment, index) => typeof segment === "number" ? `[${segment}]` : `${index === 0 ? "" : "."}${String(segment)}`
+).join("");
+const issueCodeSeparator = "\0";
+const leafCodes = {
+  InvalidType: "invalid_type",
+  InvalidValue: "invalid_value",
+  MissingKey: "missing_key",
+  UnexpectedKey: "unexpected_key",
+  Forbidden: "forbidden",
+  OneOf: "one_of"
+};
+const formatSchemaIssues = SchemaIssue.makeFormatterStandardSchemaV1({
+  leafHook: (issue) => `${issue._tag}${issueCodeSeparator}${SchemaIssue.defaultLeafHook(issue)}`
+});
+const schemaIssuesOf = (error) => formatSchemaIssues(error.issue).issues.slice(0, maxIssues).map((issue) => {
+  const separator = issue.message.indexOf(issueCodeSeparator);
+  const tagged = separator >= 0;
+  return new OutputIssue({
+    code: tagged ? leafCodes[issue.message.slice(0, separator)] : "constraint",
+    path: issuePath(issue.path),
+    message: issueMessage(tagged ? issue.message.slice(separator + issueCodeSeparator.length) : issue.message)
+  });
+});
+const textIssuesOf = (code, message) => message.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).slice(0, maxIssues).map(
+  (line) => new OutputIssue({ code, path: "", message: issueMessage(line) })
+);
+const quoted = (text) => {
+  try {
+    return typeof JSON.parse(text) === "string";
+  } catch {
+    return false;
+  }
+};
+const decode = (schema, text, attempt, value) => Effect.gen(function* () {
+  const offered = candidates(text);
+  const decoder = Schema.decodeUnknownEffect(schema);
+  let code = "no_candidate";
+  let issues = [
+    new OutputIssue({ code: "no_candidate", path: "", message: "the answer held no JSON document" })
+  ];
+  if (value !== void 0) {
+    const result = yield* Effect.result(decoder(value));
+    if (result._tag === "Success") return result.success;
+    const rawIssues = schemaIssuesOf(result.failure);
+    if (typeof value !== "string" || !rawIssues.every((issue) => issue.code === "invalid_type")) {
+      return yield* new StructuredOutputFailure({
+        code: attempt.corrections >= attempt.limit ? "correction_exhausted" : "schema_mismatch",
+        schema: digest(schema),
+        candidate: Digest.digest(JSON.stringify(value)),
+        corrections: attempt.corrections,
+        limit: attempt.limit,
+        issues: rawIssues,
+        message: `The agent's answer did not validate against its declared output schema after ${attempt.corrections} of ${attempt.limit} corrections`
+      });
+    }
+  }
+  for (const candidate of offered) {
+    if (candidate.length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(candidate);
+    } catch (error) {
+      code = "invalid_json";
+      issues = textIssuesOf("invalid_json", error.message);
+      continue;
+    }
+    const result = yield* Effect.result(decoder(parsed));
+    if (result._tag === "Success") return result.success;
+    code = "schema_mismatch";
+    issues = schemaIssuesOf(result.failure);
+  }
+  const raw = stripBom(text);
+  if (!quoted(offered[0])) {
+    const result = yield* Effect.result(decoder(raw));
+    if (result._tag === "Success") return result.success;
+    const rawIssues = schemaIssuesOf(result.failure);
+    if (code === "invalid_json" && rawIssues[0]?.code !== "invalid_type") {
+      code = "schema_mismatch";
+      issues = rawIssues;
+    }
+  }
+  return yield* new StructuredOutputFailure({
+    // Once the budget is spent, exhaustion is the actionable classification;
+    // the issue records retain whether the last candidate was invalid JSON or
+    // failed schema decoding.
+    code: attempt.corrections >= attempt.limit ? "correction_exhausted" : code,
+    schema: digest(schema),
+    candidate: Digest.digest(offered[offered.length - 1]),
+    corrections: attempt.corrections,
+    limit: attempt.limit,
+    issues,
+    message: `The agent's answer did not validate against its declared output schema after ${attempt.corrections} of ${attempt.limit} corrections`
+  });
+});
+//# sourceMappingURL=StructuredOutput.js.map

package/dist/cjs/StructuredOutput.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/StructuredOutput.ts"],
+  "sourcesContent": ["/**\n * Turning one agent's final text into a value the declared output schema\n * accepts, or into a typed failure.\n *\n * A model may answer with a bare JSON document, prose wrapped around a JSON\n * document, a fenced block, or JSON of the wrong shape. Downstream nodes must\n * never receive that ambiguity, so this module implements the recovery\n * contract in `../docs/concepts.md#structured-output`:\n *\n * 1. parse the complete, BOM-stripped response and decode it;\n * 2. otherwise scan once for balanced JSON containers, take the container\n *    whose matching close ends last, and decode that;\n * 3. otherwise report a typed {@link StructuredOutputFailure} carrying bounded\n *    diagnostics, which is what a caller re-prompts with when it still holds a\n *    correction slot.\n *\n * Every candidate is decoded by the declared schema. Extraction never relaxes\n * validation: it only decides which bytes are offered to it, and the schema may\n * accept any JSON root rather than silently requiring an object.\n *\n * The prompt half is {@link instructions}. It renders the declared schema as a\n * JSON Schema document placed in the run's system teaching, which is BAML's\n * `ctx.output_format` injection reached through the seam the vault note\n * specifies \u2014 the model is told the shape before it answers, and the answer is\n * still validated locally. Provider acceptance is not a cast.\n *\n * Reference consulted: the `generateObject` function from Effect's\n * `effect/unstable/ai/LanguageModel` module, which\n * sends `responseFormat: { type: \"json\", schema }` and then decodes the result\n * with the same schema, failing `AiError.InvalidOutputError` on mismatch. The\n * decode-and-fail-typed half is copied. The provider `responseFormat` half is\n * not reachable here: `@smthrs/model`'s `ModelRequest.GenerationParams` has no\n * response-format field, and the cell loop's final answer is a `Cell.Complete`\n * `output` string rather than a provider-decoded value, so the schema is\n * carried in the prompt and enforced at this boundary.\n *\n * @since 0.1.0\n */\n\nimport * as Digest from \"@smthrs/core/Digest\"\nimport * as Fault from \"@smthrs/flow/Fault\"\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport * as SchemaIssue from \"effect/SchemaIssue\"\nimport * as elide from \"./internal/elide.ts\"\n\n/**\n * Stable reasons a structured-output boundary failed.\n *\n * `invalid_json` means candidate text was not JSON. `schema_mismatch` means\n * JSON parsed but the declared schema refused it. `no_candidate` means the\n * answer contained no candidate text. `correction_exhausted` means the\n * boundary had already spent its correction budget.\n *\n * @category models\n * @since 1.0.0-rc.0\n * @slop\n */\nexport const StructuredOutputFailureCode = Schema.Literals([\n  \"invalid_json\",\n  \"schema_mismatch\",\n  \"no_candidate\",\n  \"correction_exhausted\"\n])\n\n/**\n * Stable reasons a structured-output boundary failed.\n *\n * @category models\n * @since 1.0.0-rc.0\n * @slop\n */\nexport type StructuredOutputFailureCode = typeof StructuredOutputFailureCode.Type\n\n/**\n * Stable reasons an individual structured-output issue was reported.\n *\n * `invalid_json` means candidate text was not JSON. `no_candidate` means the\n * answer contained no candidate text. `invalid_type` means a decoded value had\n * the wrong type. `invalid_value` means a value of the expected type was still\n * invalid. `missing_key` means a required property was absent.\n * `unexpected_key` means a prohibited extra property was present. `forbidden`\n * means decoding attempted an operation the schema forbids. `one_of` means\n * more than one exclusive union member matched. `constraint` means a schema\n * check or empty-union fallback failed.\n *\n * @category models\n * @since 1.0.0-rc.0\n * @slop\n */\nexport const OutputIssueCode = Schema.Literals([\n  \"invalid_json\",\n  \"no_candidate\",\n  \"invalid_type\",\n  \"invalid_value\",\n  \"missing_key\",\n  \"unexpected_key\",\n  \"forbidden\",\n  \"one_of\",\n  \"constraint\"\n])\n\n/**\n * Stable reasons an individual structured-output issue was reported.\n *\n * @category models\n * @since 1.0.0-rc.0\n * @slop\n */\nexport type OutputIssueCode = typeof OutputIssueCode.Type\n\n/**\n * One bounded issue raised while decoding structured output.\n *\n * @category models\n * @since 1.0.0-rc.0\n * @slop\n */\nexport class OutputIssue extends Schema.Class<OutputIssue>(\"flows/harness/StructuredOutput/OutputIssue\")({\n  /** The stable reason this issue was reported. */\n  code: OutputIssueCode,\n  /** The JSON path of the offending value, dot/bracket joined; empty for the root. */\n  path: Schema.String,\n  /** What the decoder wanted there. */\n  message: Schema.String\n}) {\n  /** Renders the issue for existing prose-oriented consumers. */\n  override toString(): string {\n    return this.path === \"\" ? this.message : `${this.path}: ${this.message}`\n  }\n}\n\n/**\n * The terminal failure of one structured-output boundary.\n *\n * It carries what an operator needs to tell two identical-looking refusals\n * apart: which schema was demanded, how many correction slots the attempt\n * consumed out of its budget, the digest of the last candidate that was\n * offered to the decoder, and the bounded issue list.\n *\n * @category errors\n * @since 0.1.0\n * @slop\n */\nexport class StructuredOutputFailure extends Schema.TaggedError<StructuredOutputFailure>()(\n  \"/harness/StructuredOutputFailure\",\n  {\n    /** The stable reason this boundary failed. */\n    code: StructuredOutputFailureCode,\n    /** The declared output schema's canonical digest. */\n    schema: Schema.String,\n    /** SHA-256 of the text the decoder was last offered. */\n    candidate: Schema.String,\n    /** Correction attempts already spent on this boundary. */\n    corrections: Schema.Number,\n    /** The correction budget the boundary was declared with. */\n    limit: Schema.Number,\n    /** At most {@link maxIssues} structured validation issues. */\n    issues: Schema.Array(OutputIssue),\n    message: Schema.String\n  }\n) {}\n// The model's answer did not fit the declared shape: another model may answer it.\nFault.register(\"/harness/StructuredOutputFailure\", \"dependency\")\n\n/**\n * The most validation issues a failure or a correction prompt carries.\n *\n * Bounded for the same reason smithers bounds its own validation summary: a\n * wide struct that mismatched everywhere would otherwise spend the correction\n * prompt's whole budget restating the schema back to the model.\n *\n * @category constants\n * @since 0.1.0\n * @slop\n */\nexport const maxIssues = 5\n\n/**\n * The JSON Schema document for a declared output schema.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const jsonSchema = (schema: Schema.Top): unknown => {\n  const document = Schema.toJsonSchemaDocument(schema, { onExcessProperty: \"error\" })\n  return Object.keys(document.definitions).length > 0\n    ? { ...document.schema, $defs: document.definitions }\n    : document.schema\n}\n\n/**\n * The canonical digest of a declared output schema.\n *\n * Two declarations that render the same JSON Schema name the same boundary, so\n * this is what a step key folds in rather than the schema value itself.\n *\n * @category identity\n * @since 0.1.0\n * @slop\n */\nexport const digest = (schema: Schema.Top): string => Digest.digest(Digest.canonical(jsonSchema(schema)))\n\n/**\n * The system teaching that tells a run what its final `output` must be.\n *\n * Written against the cell contract: a cell finishes by calling\n * `ctx.done(output)`, and the sandbox rejects a returned transition, so the\n * instruction is about the argument of that call and not about the assistant\n * message around it. The run passes the value itself: a structured value\n * reaches {@link decode} as canonical JSON, and a string as its own text.\n *\n * @category prompts\n * @since 0.1.0\n * @slop\n */\nexport const instructions = (schema: Schema.Top): string =>\n  `## Required output shape\n\nFinish by calling \\`ctx.done(output)\\` with the value itself: a JavaScript\nvalue that validates against this JSON Schema, such as\n\\`ctx.done({ ...fields })\\`. Do not stringify it, and add no prose around it.\n\n\\`\\`\\`json\n${JSON.stringify(jsonSchema(schema), null, 2)}\n\\`\\`\\``\n\n/**\n * The digest of one failure's rendered validation issues.\n *\n * Two rejections that raised the same issues share this digest, which is what a\n * record carries instead of the issues themselves: a journal that repeated the\n * validator's prose for every correction would grow with the model's verbosity,\n * and what an operator actually asks is whether the second answer was wrong the\n * same way as the first.\n *\n * @category identity\n * @since 0.1.0\n */\nexport const issuesDigest = (failure: StructuredOutputFailure): string =>\n  Digest.digest(\n    Digest.canonical(failure.issues.map((issue) => ({ path: issue.path, message: issue.message })))\n  )\n\n/**\n * The correction teaching appended when a candidate failed to decode.\n *\n * It restates the schema and the bounded diagnostics and nothing else: a\n * correction does not reinterpret the task, so the original prompt is repeated\n * verbatim by the caller and only this section is new.\n *\n * @category prompts\n * @since 0.1.0\n * @slop\n */\nexport const correction = (failure: StructuredOutputFailure): string =>\n  `## Your previous answer did not validate\n\nThe output you passed to \\`ctx.done\\` could not be decoded against the required\nschema. Call \\`ctx.done(output)\\` again with the same information as a value\nthat validates.\n\nValidation issues:\n${failure.issues.map((issue) => `- ${issue}`).join(\"\\n\")}`\n\nconst stripBom = (text: string): string => text.charCodeAt(0) === 0xfeff ? text.slice(1) : text\n\n/**\n * The balanced JSON container whose matching close ends last.\n *\n * Scans once, left to right, tracking object and array delimiters, quoted\n * strings, and escapes. A mismatched close abandons the open container rather\n * than pairing it with the wrong opener, so a truncated prefix cannot be\n * reported as a complete document. `undefined` means the text holds no\n * balanced container at all.\n *\n * This is the array-capable form of smithers' `extractLastBalancedJson`, which\n * is object-only.\n *\n * @category extraction\n * @since 0.1.0\n * @slop\n */\nexport const lastBalanced = (text: string): string | undefined => {\n  const stack: Array<string> = []\n  let start = -1\n  let found: string | undefined = undefined\n  let quoted = false\n  let escaped = false\n  for (let index = 0; index < text.length; index++) {\n    const char = text[index]!\n    if (quoted) {\n      if (escaped) escaped = false\n      else if (char === \"\\\\\") escaped = true\n      else if (char === \"\\\"\") quoted = false\n      continue\n    }\n    if (char === \"\\\"\") {\n      if (stack.length > 0) quoted = true\n      continue\n    }\n    if (char === \"{\" || char === \"[\") {\n      if (stack.length === 0) start = index\n      stack.push(char)\n      continue\n    }\n    if (char === \"}\" || char === \"]\") {\n      const opener = stack.pop()\n      if (opener === undefined) continue\n      if ((char === \"}\") !== (opener === \"{\")) {\n        // Mismatched close: abandon the whole open container rather than\n        // reporting a pairing the text does not contain.\n        stack.length = 0\n        start = -1\n        continue\n      }\n      if (stack.length === 0 && start >= 0) found = text.slice(start, index + 1)\n    }\n  }\n  return found\n}\n\n/**\n * The candidates offered to the decoder, in the declared recovery order.\n *\n * @category extraction\n * @since 0.1.0\n * @slop\n */\nexport const candidates = (text: string): ReadonlyArray<string> => {\n  const stripped = stripBom(text).trim()\n  const balanced = lastBalanced(stripped)\n  return balanced === undefined || balanced === stripped ? [stripped] : [stripped, balanced]\n}\n\nconst issueMessage = (message: string): string => elide.head(message, 240, \"reissue the answer to see the whole issue\")\n\nconst issuePath = (path: ReadonlyArray<PropertyKey>): string =>\n  path.map((segment, index) =>\n    typeof segment === \"number\" ? `[${segment}]` : `${index === 0 ? \"\" : \".\"}${String(segment)}`\n  ).join(\"\")\n\ntype FormattedIssue = {\n  readonly message: string\n  readonly path: ReadonlyArray<PropertyKey>\n}\n\nconst issueCodeSeparator = \"\\u0000\"\n\nconst leafCodes: Record<SchemaIssue.Leaf[\"_tag\"], OutputIssueCode> = {\n  InvalidType: \"invalid_type\",\n  InvalidValue: \"invalid_value\",\n  MissingKey: \"missing_key\",\n  UnexpectedKey: \"unexpected_key\",\n  Forbidden: \"forbidden\",\n  OneOf: \"one_of\"\n}\n\nconst formatSchemaIssues = SchemaIssue.makeFormatterStandardSchemaV1({\n  leafHook: (issue) => `${issue._tag}${issueCodeSeparator}${SchemaIssue.defaultLeafHook(issue)}`\n})\n\nconst schemaIssuesOf = (error: Schema.SchemaError): ReadonlyArray<OutputIssue> =>\n  (formatSchemaIssues(error.issue).issues as ReadonlyArray<FormattedIssue>).slice(0, maxIssues).map((issue) => {\n    const separator = issue.message.indexOf(issueCodeSeparator)\n    const tagged = separator >= 0\n    return new OutputIssue({\n      code: tagged ? leafCodes[issue.message.slice(0, separator) as SchemaIssue.Leaf[\"_tag\"]] : \"constraint\",\n      path: issuePath(issue.path),\n      message: issueMessage(tagged ? issue.message.slice(separator + issueCodeSeparator.length) : issue.message)\n    })\n  })\n\nconst textIssuesOf = (code: OutputIssueCode, message: string): ReadonlyArray<OutputIssue> =>\n  message.split(\"\\n\").map((line) => line.trim()).filter((line) => line.length > 0).slice(0, maxIssues).map((line) =>\n    new OutputIssue({ code, path: \"\", message: issueMessage(line) })\n  )\n\nconst quoted = (text: string): boolean => {\n  try {\n    return typeof JSON.parse(text) === \"string\"\n  } catch {\n    return false\n  }\n}\n\n/**\n * Decodes one agent answer with the declared output schema.\n *\n * Decodes an original completion value first when supplied. Only a string\n * refused for its type proceeds to legacy text extraction; refinements and\n * nonstring failures retain the original value's diagnostics.\n * Tries every {@link candidates} entry in order and returns the first the\n * schema accepts, then the answer itself, untrimmed, as a string unless it is\n * a JSON string literal, which is how a `ctx.done(\"text\")` answer reaches a\n * string schema. When none does, the failure reports the issues raised by the\n * LAST candidate, which is the narrowest text the extractor could isolate and\n * therefore the one a correction prompt should be about.\n *\n * @category decoding\n * @since 0.1.0\n * @slop\n */\nexport const decode = <S extends Schema.Top>(\n  schema: S,\n  text: string,\n  attempt: { readonly corrections: number; readonly limit: number },\n  value?: Schema.Json | undefined\n): Effect.Effect<S[\"Type\"], StructuredOutputFailure, S[\"DecodingServices\"]> =>\n  Effect.gen(function*() {\n    const offered = candidates(text)\n    const decoder = Schema.decodeUnknownEffect(schema)\n    let code: StructuredOutputFailureCode = \"no_candidate\"\n    let issues: ReadonlyArray<OutputIssue> = [\n      new OutputIssue({ code: \"no_candidate\", path: \"\", message: \"the answer held no JSON document\" })\n    ]\n    if (value !== undefined) {\n      const result = yield* Effect.result(decoder(value))\n      if (result._tag === \"Success\") return result.success\n      const rawIssues = schemaIssuesOf(result.failure)\n      // Extraction is only for text offered to a schema expecting another type.\n      // Preserve string refinements and nonstring type failures on the value.\n      if (typeof value !== \"string\" || !rawIssues.every((issue) => issue.code === \"invalid_type\")) {\n        return yield* new StructuredOutputFailure({\n          code: attempt.corrections >= attempt.limit ? \"correction_exhausted\" : \"schema_mismatch\",\n          schema: digest(schema),\n          candidate: Digest.digest(JSON.stringify(value)),\n          corrections: attempt.corrections,\n          limit: attempt.limit,\n          issues: rawIssues,\n          message:\n            `The agent's answer did not validate against its declared output schema after ${attempt.corrections} of ${attempt.limit} corrections`\n        })\n      }\n    }\n    for (const candidate of offered) {\n      if (candidate.length === 0) continue\n      let parsed: unknown\n      try {\n        parsed = JSON.parse(candidate)\n      } catch (error) {\n        code = \"invalid_json\"\n        // The ECMAScript JSON parser throws a SyntaxError with a message.\n        issues = textIssuesOf(\"invalid_json\", (error as SyntaxError).message)\n        continue\n      }\n      const result = yield* Effect.result(decoder(parsed))\n      if (result._tag === \"Success\") return result.success\n      code = \"schema_mismatch\"\n      issues = schemaIssuesOf(result.failure)\n    }\n    // `ctx.done(\"text\")` reaches the boundary as the text itself, not as a\n    // JSON string, so a schema that accepts the raw answer takes it as it is.\n    // An answer that is a whole JSON string literal already said which string\n    // it meant, and its quotes are not part of it.\n    // Untrimmed, so an empty or whitespace-bearing string arrives as written.\n    const raw = stripBom(text)\n    if (!quoted(offered[0]!)) {\n      const result = yield* Effect.result(decoder(raw))\n      if (result._tag === \"Success\") return result.success\n      // A string the schema read and refused on its merits (too short, not\n      // one of the literals) is the issue to correct, not the JSON parse. A\n      // schema that wanted no string at all keeps the JSON diagnosis.\n      const rawIssues = schemaIssuesOf(result.failure)\n      if (code === \"invalid_json\" && rawIssues[0]?.code !== \"invalid_type\") {\n        code = \"schema_mismatch\"\n        issues = rawIssues\n      }\n    }\n    return yield* new StructuredOutputFailure({\n      // Once the budget is spent, exhaustion is the actionable classification;\n      // the issue records retain whether the last candidate was invalid JSON or\n      // failed schema decoding.\n      code: attempt.corrections >= attempt.limit ? \"correction_exhausted\" : code,\n      schema: digest(schema),\n      candidate: Digest.digest(offered[offered.length - 1]!),\n      corrections: attempt.corrections,\n      limit: attempt.limit,\n      issues,\n      message:\n        `The agent's answer did not validate against its declared output schema after ${attempt.corrections} of ${attempt.limit} corrections`\n    })\n  })\n"],
+  "mappings": "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",
+  "names": ["quoted"]
+}