@wildo-ai/external-connectors-models 1.1.3 → 1.1.5

package/dist/esm/protocols/llm.external-connectors-models.schemas.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ExternalProvider_ExchangeProtocol_Kind, ExternalProvider_ExchangeProtocol_Status_BaseSchema } from "../core/commons.external-connectors-models.schemas.js";
+import { ExternalProvider_ExchangeProtocol_Kind } from "../core/commons.external-connectors-models.schemas.js";
 import { ExternalProvider_OperationContextSchema } from "../core/operations.external-connectors-models.schemas.js";
 //===============================================================
 // LLM Provider
@@ -55,7 +55,9 @@ export var LLM_Model;
     // rejects temperature+topP together.
     /** Anthropic's most intelligent generally-available model (Claude 5 family, Mythos-class tier). */
     LLM_Model["CLAUDE_FABLE_5"] = "claude-fable-5";
-    /** Claude 5 family Opus tier. Same no-sampling-params contract as the rest of the family. */
+    /** Claude 5 family Opus tier, 5.5 revision. Same no-sampling-params contract as the rest of the family. */
+    LLM_Model["CLAUDE_OPUS_5_5"] = "claude-opus-5-5";
+    /** Claude 5 family Opus tier (superseded by CLAUDE_OPUS_5_5). Same no-sampling-params contract as the rest of the family. */
     LLM_Model["CLAUDE_OPUS_5"] = "claude-opus-5";
     /** Claude 5 family workhorse. */
     LLM_Model["CLAUDE_SONNET_5"] = "claude-sonnet-5";
@@ -125,12 +127,13 @@ export var LLM_Model_Thinking_Capability;
     LLM_Model_Thinking_Capability["OPTIONAL"] = "optional";
     /**
      * The model ALWAYS reasons and thinking CANNOT be disabled (o-series,
-     * `claude-fable-5`). Every effort is valid EXCEPT `NONE` — asking such a model
+     * `claude-fable-5`, `claude-opus-5-5`). Every effort is valid EXCEPT `NONE` — asking such a model
      * not to think is a provider error, not a preference.
      *
      * NOT a property of a model FAMILY: measured 2026-09-08, `claude-fable-5`
      * refuses `thinking.type.disabled` while `claude-sonnet-5` and
-     * `claude-opus-5` accept it. Both siblings carried this value on the family's
+     * `claude-opus-5` accept it — and on 2026-09-24 `claude-opus-5-5` refused it,
+     * so even two revisions of one tier differ. Both siblings carried this value on the family's
      * behalf for a month, which made `validateReasoningEffortForModel` refuse a
      * configuration the provider would have honoured.
      */
@@ -315,12 +318,13 @@ export const LLMProvider_ToolChoice_Schema = z.union([
  * | Model                                | Supported                       | Rejected                      |
  * |--------------------------------------|---------------------------------|-------------------------------|
  * | GPT-5.6 sol / terra / luna           | none, low, medium, high, xhigh  | `minimal`, `provider-default` |
- * | claude-fable-5                       | low, medium, high, xhigh        | **`none`**, `minimal`, `provider-default` |
+ * | claude-fable-5 · claude-opus-5-5     | low, medium, high, xhigh        | **`none`**, `minimal`, `provider-default` |
  * | claude-sonnet-5 · claude-opus-5      | none, low, medium, high, xhigh  | `minimal`, `provider-default` |
  *
  * ⚠️ `NONE` is NOT portable, but the line is finer than "OpenAI yes, Anthropic
- * no": `claude-fable-5` alone refuses it. Its siblings accept it, so a level
- * that is legal on `claude-sonnet-5` can still be illegal on `claude-fable-5` —
+ * no": `claude-fable-5` and `claude-opus-5-5` refuse it while `claude-sonnet-5`
+ * and `claude-opus-5` accept it, so a level legal on one Opus revision is
+ * illegal on the next —
  * which is why the capability is a per-model probed fact and never a family
  * assumption. `PROVIDER_DEFAULT` is rejected as an explicit value by BOTH
  * providers — omit the field entirely for the model's own default.
@@ -433,9 +437,10 @@ export const LLM_MODEL_CATALOG = {
     // Thinking posture re-probed 2026-09-08 and it is PER MODEL, not per family.
     // `claude-fable-5` refuses `thinking: {type:'disabled'}` (400 "…is not
     // supported for this model; thinking defaults to adaptive") — ALWAYS.
-    // `claude-sonnet-5` and `claude-opus-5` ACCEPT it (200) — OPTIONAL. All three
-    // reject `minimal` and `provider-default` as `output_config.effort` values,
-    // whose accepted set is `low|medium|high|xhigh|max`.
+    // `claude-sonnet-5` and `claude-opus-5` ACCEPT it (200) — OPTIONAL.
+    // `claude-opus-5-5` (probed 2026-09-24) REFUSES it, like fable — ALWAYS. All
+    // four reject `minimal` and `provider-default` as `output_config.effort`
+    // values, whose accepted set is `low|medium|high|xhigh|max`.
     // ---------------------------------------------------------------
     [LLM_Model.CLAUDE_FABLE_5]: {
         providerRef: "anthropic",
@@ -452,8 +457,35 @@ export const LLM_MODEL_CATALOG = {
             LLM_Model_IO_Capability.TOOL_USE,
             LLM_Model_IO_Capability.LONG_CONTEXT,
         ],
-        // The ONLY model that still refuses `thinking: {type:'disabled'}` (re-probed
-        // 2026-09-08); its two siblings accept it, so this value is not the family's.
+        // Refuses `thinking: {type:'disabled'}` (re-probed 2026-09-08). Sonnet 5 and Opus 5 accept it
+        // and Opus 5.5 refuses it (2026-09-24), so this value is per model, never the family's.
+        thinkingCapability: LLM_Model_Thinking_Capability.ALWAYS,
+        unsupportedReasoningEfforts: [LLMProvider_ReasoningEffort.MINIMAL, LLMProvider_ReasoningEffort.PROVIDER_DEFAULT],
+        rejectsExplicitTemperature: true,
+    },
+    [LLM_Model.CLAUDE_OPUS_5_5]: {
+        providerRef: "anthropic",
+        availability: LLM_Model_Availability.PRODUCTION,
+        // Probed live 2026-09-24 through `live-model-smoke.test.ts` (generation, temperature
+        // rejection, thinking posture and every effort level) when the ACP coding/research lane
+        // moved onto it. Every value below is that measurement, not an inheritance from CLAUDE_OPUS_5 —
+        // and the measurement DISAGREED with Opus 5 on thinking: 5.5 refuses `thinking: {type:'disabled'}`
+        // (400 "…is not supported for this model. Use thinking.type.adaptive…"), so it is ALWAYS, as
+        // Fable is, where Opus 5 is OPTIONAL. Copying the sibling row would have been wrong.
+        probedOn: "2026-09-24",
+        applicabilities: [
+            LLM_Model_Applicability.DEEP_JUDGMENT,
+            LLM_Model_Applicability.LONG_CONTEXT_ANALYSIS,
+            LLM_Model_Applicability.STRUCTURED_AUTHORING,
+            LLM_Model_Applicability.WORKSPACE_CODING_AGENT,
+        ],
+        ioCapabilities: [
+            LLM_Model_IO_Capability.MULTIMODAL_VISION,
+            LLM_Model_IO_Capability.STRUCTURED_OUTPUTS,
+            LLM_Model_IO_Capability.TOOL_USE,
+            LLM_Model_IO_Capability.CODE_GENERATION,
+            LLM_Model_IO_Capability.LONG_CONTEXT,
+        ],
         thinkingCapability: LLM_Model_Thinking_Capability.ALWAYS,
         unsupportedReasoningEfforts: [LLMProvider_ReasoningEffort.MINIMAL, LLMProvider_ReasoningEffort.PROVIDER_DEFAULT],
         rejectsExplicitTemperature: true,
@@ -965,14 +997,52 @@ export var LLMProvider_StructuredGenerationFailureKind;
 /**
  * One structural validation issue recovered from the SDK/Zod cause chain.
  *
- * `code` + `path` ONLY, never the issue's `message`: a provider validation error
- * retains the rejected value in its message, so carrying it would copy private model
- * output into any log, trace or persisted failure record that receives this reason.
- * The path is what a caller actually needs — it names the field the model omitted.
+ * Never the issue's `message`: a provider validation error retains the rejected value in its message,
+ * so carrying it would copy private model output into any log, trace or persisted failure record that
+ * receives this reason. The path names the field the model got wrong.
+ *
+ * ## What the SCHEMA expected, which is not model output
+ *
+ * A path and a code say WHERE and roughly WHAT, and that is not enough for a retry to succeed. Measured
+ * 2026-09-13 on Wonder CRM's `document-release-policy`: three attempts in a row were rejected with
+ * `operatorAttestationLimitationRefs: invalid_type`, and the model repeated the same answer each time
+ * because nothing told it an ARRAY was expected. Zod 4 carries that in fields separate from the message,
+ * and every one of them is read off the SCHEMA, never off the value:
+ *
+ * - `expected` — the type an `invalid_type` wanted (`array`, `string`);
+ * - `format` / `pattern` — the format an `invalid_format` wanted, and the schema's own regex;
+ * - `values` — the options an `invalid_value` admits, i.e. the enum's members;
+ * - `keys` — the key names an `unrecognized_keys` found. Schema shape against a strict object, and it
+ *   was PROJECTED by the provider service while this schema did not declare it, so the caller-side
+ *   parse silently stripped it — the diagnosis its projection existed for never arrived.
+ *
+ * ## The one code for which the MESSAGE is the only content: `custom`
+ *
+ * A `custom` issue is raised by a `.refine()` / `.superRefine()` this repository AUTHORED, and it carries
+ * none of the fields above — no `expected`, no `values`, nothing read off a leaf schema, because what it
+ * refuses is a relationship BETWEEN fields that no leaf can state. Its message is where the author wrote
+ * that relationship down, so an issue projected without it says `sharedResponsibility: custom` and nothing
+ * else. Measured 2026-09-16 on Wonder CRM's `top_down.compliance-conception`: three attempts in a row were
+ * refused on `obligations.N.sharedResponsibility: custom` and the model could not correct an answer whose
+ * rule — "several governance actors require a shared-responsibility judgement" — never reached it.
+ *
+ * It is SAFE for the same reason the fields above are, and for no weaker one: the text is the schema
+ * author's, written in this repository's source, not the provider's rendering of the rejected value.
+ * `code: "custom"` is what guarantees that — every other code's message is composed by Zod around the
+ * input. **A refinement author therefore owes this field a message that names schema-shaped identifiers
+ * only** — a slug, a ref, a key, an index — exactly the category `keys` already admits, and never a
+ * fragment of the rejected content.
  */
 export const LLMProvider_StructuredValidationIssueSchema = z.object({
     code: z.string(),
     path: z.array(z.union([z.string(), z.number()])),
+    expected: z.string().optional(),
+    format: z.string().optional(),
+    pattern: z.string().optional(),
+    values: z.array(z.string()).optional(),
+    keys: z.array(z.string()).optional(),
+    /** The authored message of a `custom` refinement, and present for no other code. See above. */
+    refinementMessage: z.string().optional(),
 });
 /**
  * The reason a structured generation produced no object, carried back to the CALLER.
@@ -1006,7 +1076,18 @@ export const LLMProvider_StructuredValidationIssueSchema = z.object({
  */
 export const LLMProvider_StructuredGenerationFailureSchema = z.object({
     kind: z.enum(LLMProvider_StructuredGenerationFailureKind),
-    /** Human-readable one-liner, resolved through the engine's caught-error description. */
+    /**
+     * Human-readable one-liner, built from PAYLOAD-FREE facts — the thrown value's `name` and this
+     * failure's `kind`.
+     *
+     * Deliberately NOT the caught error's own message, which is what it used to be. A provider's
+     * structured-generation error serializes the WHOLE error into its message — the model's rejected
+     * `text`, the `response.body`, the validation `value` — so resolving this field through it copied
+     * private model output into every log, trace and persisted failure record that receives this
+     * envelope, breaking the Privacy note above. Same reasoning as
+     * {@link LLMProvider_StructuredValidationIssueSchema}, which drops each issue's message for
+     * exactly this reason one field over.
+     */
     message: z.string(),
     /** The thrown value's `name` when it had one, else its `typeof`. */
     errorName: z.string().optional(),
@@ -1035,26 +1116,39 @@ export const LLMProvider_StructuredGenerationFailureSchema = z.object({
     rootKeys: z.array(z.string()).optional(),
 });
 /**
- * Read the structured-generation failure reason off an invocation's `executionContext`.
+ * Render ONE validation issue as `path: code (what the schema wanted)`.
  *
- * THE supported way to reach it. Provided as a function rather than left to each caller
- * because the alternative is the cast every `usage` reader already hand-rolls
- * (`response.executionContext as { usage?: … }`) — N copies of one shape, each free to
- * drift from the schema, none of them validated. Here the schema IS the reader.
+ * THE renderer for an issue, and the reason it is exported rather than inlined into the failure line
+ * below: a caller that needs issues one at a time — the meta-workflow generation port turns each into a
+ * finding fed back to the model — otherwise hand-rolls this list, and every field added to the issue
+ * afterwards reaches one copy. That has now happened three times, each time silently, each time costing
+ * live runs: the paths themselves were dropped (2026-08-29), then `expected` (2026-09-13), then a
+ * `custom` refinement's message (2026-09-16). Keeping one renderer means a site that reports an issue at
+ * all reports the whole issue.
  *
- * Returns `undefined` both when the generation succeeded and when the context predates
- * this field, so a caller never has to distinguish "no failure" from "no reason
- * recorded" — in either case there is nothing more specific to report than the absence
- * of an object.
+ * Carries no generated text — see {@link LLMProvider_StructuredValidationIssueSchema} for why each field
+ * it prints is schema shape rather than the rejected value.
  */
+export function describeStructuredValidationIssue(issue) {
+    // What the schema expected rides beside the code: "invalid_type" alone does not say "array", and
+    // `custom` says nothing at all without the refinement's own words — which is why that one comes first.
+    const hints = [
+        ...(issue.refinementMessage ? [issue.refinementMessage] : []),
+        ...(issue.expected ? [`expected ${issue.expected}`] : []),
+        ...(issue.format ? [`format ${issue.format}`] : []),
+        ...(issue.pattern ? [`must match ${issue.pattern}`] : []),
+        ...(issue.values?.length ? [`one of ${issue.values.join(" | ")}`] : []),
+        ...(issue.keys?.length ? [`unexpected key(s) ${issue.keys.join(", ")}`] : []),
+    ];
+    const where = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+    return `${where}: ${issue.code}${hints.length > 0 ? ` (${hints.join("; ")})` : ""}`;
+}
 /**
  * Render a structured-generation failure as one operator-readable line.
  *
- * Lives here, beside the schema, rather than in each caller: the two labelling
- * orchestrators alone would otherwise have hand-rolled the same rendering twice, and the
- * value of `validationIssues` is entirely in how it is presented — a caller that quietly
- * drops it reports "no object" with extra words. Keeping one renderer means a site that
- * reports the reason at all reports the whole reason.
+ * Lives here, beside the schema, rather than in each caller: the two labelling orchestrators alone would
+ * otherwise have hand-rolled the same rendering twice, and the value of `validationIssues` is entirely in
+ * how it is presented — a caller that quietly drops it reports "no object" with extra words.
  *
  * Carries no generated text, only its length — see
  * {@link LLMProvider_StructuredGenerationFailureSchema}.
@@ -1065,16 +1159,26 @@ export function describeStructuredGenerationFailure(failure) {
         parts.push(`finishReason=${failure.finishReason}`);
     }
     if (failure.validationIssues !== undefined && failure.validationIssues.length > 0) {
-        const issues = failure.validationIssues
-            .map((issue) => `${issue.path.length > 0 ? issue.path.join(".") : "<root>"} (${issue.code})`)
-            .join(", ");
-        parts.push(`schema paths: ${issues}`);
+        parts.push(`schema paths: ${failure.validationIssues.map(describeStructuredValidationIssue).join(", ")}`);
     }
     if (failure.generatedTextLength !== undefined && failure.generatedTextLength !== null) {
         parts.push(`generatedTextLength=${failure.generatedTextLength}`);
     }
     return parts.join(" \u00b7 ");
 }
+/**
+ * Read the structured-generation failure reason off an invocation's `executionContext`.
+ *
+ * THE supported way to reach it. Provided as a function rather than left to each caller
+ * because the alternative is the cast every `usage` reader already hand-rolls
+ * (`response.executionContext as { usage?: … }`) — N copies of one shape, each free to
+ * drift from the schema, none of them validated. Here the schema IS the reader.
+ *
+ * Returns `undefined` both when the generation succeeded and when the context predates
+ * this field, so a caller never has to distinguish "no failure" from "no reason
+ * recorded" — in either case there is nothing more specific to report than the absence
+ * of an object.
+ */
 export function readStructuredGenerationFailure(executionContext) {
     if (typeof executionContext !== "object" || executionContext === null)
         return undefined;
@@ -1186,9 +1290,24 @@ export const LLMProvider_GenerateStructuredInputSchema = z.object({
      * data URI or an image URL. Generic across providers/models; no domain logic.
      */
     images: z.array(LLMProvider_ImageContentSchema).optional(),
+    /**
+     * OPT-IN: when the provider rejects the answer against `schema`, return the rejected answer's TEXT as
+     * `rejectedAnswer` on the output, so a caller that retries can show the model what it wrote.
+     *
+     * Opt-in because the rejected text is model output, and the default for every caller stays "no generated
+     * text on a failed call". It is carried on the OUTPUT — never on the execution context, whose telemetry
+     * every trace sink emits at every level — so it is persisted exactly where and when a successful answer
+     * is: only as an agent-call payload, only at `DEBUG_VERBOSE`. It never reaches the failure log line.
+     *
+     * Added 2026-09-13 (#1143): a playbook retry that could not see its own answer fixed each reported field
+     * and broke another, three attempts in a row, on every family of Wonder CRM's compliance-conception run.
+     */
+    includeRejectedAnswer: z.boolean().optional(),
 });
 export const LLMProvider_GenerateStructuredOutputSchema = z.object({
     object: z.unknown(),
+    /** The rejected answer's text, present only when the input set `includeRejectedAnswer` and no object was produced. */
+    rejectedAnswer: z.string().optional(),
 });
 // Chat Multimodal Operation (for models with MULTIMODAL_VISION/AUDIO/VIDEO capability)
 export const LLMProvider_ChatMultimodalInputSchema = z.object({
@@ -1207,10 +1326,4 @@ export const LLMProvider_StreamStructuredOutputSchema = z.object({
     partialObject: z.unknown().optional(),
     object: z.unknown().optional(),
 });
-// ===============================================================
-// STATUS
-// ===============================================================
-export const LLMProvider_StatusSchema = ExternalProvider_ExchangeProtocol_Status_BaseSchema.extend({
-    protocolKind: z.literal(ExternalProvider_ExchangeProtocol_Kind.LLM_PROVIDER),
-});
 //# sourceMappingURL=llm.external-connectors-models.schemas.js.map