@cognipeer/agent-sdk 0.12.0 → 0.14.0

package/dist/index.cjs

@@ -2026,27 +2026,71 @@ function convertMessageListToSections(messageList) {
   }
   return sections.length > 0 ? sections : void 0;
 }
-function createTraceSession(opts) {
+function readTraceContinuation(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const raw = value;
+  if (raw.v !== 1 || typeof raw.sessionId !== "string" || raw.sessionId.length === 0) return void 0;
+  const nextSequence = Number(raw.nextSequence);
+  const startedAt = Number(raw.startedAt);
+  const part = Number(raw.part);
+  if (!Number.isInteger(nextSequence) || nextSequence < 1) return void 0;
+  if (!Number.isFinite(startedAt) || !Number.isInteger(part) || part < 1) return void 0;
+  const summary = raw.summary && typeof raw.summary === "object" ? { ...createEmptySummary(), ...raw.summary } : createEmptySummary();
+  summary.eventCounts = { ...raw.summary?.eventCounts ?? {} };
+  return {
+    v: 1,
+    sessionId: raw.sessionId,
+    traceId: typeof raw.traceId === "string" ? raw.traceId : void 0,
+    rootSpanId: typeof raw.rootSpanId === "string" ? raw.rootSpanId : void 0,
+    threadId: typeof raw.threadId === "string" ? raw.threadId : void 0,
+    startedAt,
+    nextSequence,
+    part,
+    summary,
+    errors: Array.isArray(raw.errors) ? raw.errors : []
+  };
+}
+function traceContinuationOf(session) {
+  return {
+    v: 1,
+    sessionId: session.sessionId,
+    traceId: session.traceId,
+    rootSpanId: session.rootSpanId,
+    threadId: session.threadId,
+    startedAt: session.startedAt,
+    nextSequence: (session.sequenceOffset ?? 0) + session.events.length + 1,
+    part: session.part ?? 1,
+    summary: JSON.parse(JSON.stringify(session.summary)),
+    // Sink failures belong to the part that hit them; carrying them on would
+    // mark every later part `partial`.
+    errors: session.errors.filter((error) => error.type !== "sink")
+  };
+}
+function createTraceSession(opts, continuation) {
   const cfg = withDefaults(opts.tracing);
   if (!cfg.enabled) return void 0;
   const providedSessionId = opts.tracing?.sessionId?.trim();
-  const sessionId = providedSessionId || generateSessionId();
-  const traceId = generateTraceId();
-  const rootSpanId = generateSpanId();
+  const sessionId = continuation?.sessionId || providedSessionId || generateSessionId();
+  const traceId = continuation?.traceId || generateTraceId();
+  const rootSpanId = continuation?.rootSpanId || generateSpanId();
   const runtime = {
     sessionId,
     traceId,
     rootSpanId,
-    threadId: opts.tracing?.threadId,
+    threadId: continuation?.threadId ?? opts.tracing?.threadId,
     configAgentName: opts.tracing?.agentName?.trim() || void 0,
     configMetadata: opts.tracing?.metadata && Object.keys(opts.tracing.metadata).length > 0 ? opts.tracing.metadata : void 0,
-    startedAt: Date.now(),
+    startedAt: continuation?.startedAt ?? Date.now(),
     resolvedConfig: cfg,
     events: [],
-    summary: createEmptySummary(),
+    summary: continuation ? continuation.summary : createEmptySummary(),
     status: "in_progress",
-    errors: [],
-    sessionStarted: false
+    errors: continuation ? [...continuation.errors] : [],
+    // A continued session was announced by its first part; announcing it
+    // again would reset a streaming receiver's copy.
+    sessionStarted: Boolean(continuation),
+    sequenceOffset: continuation ? continuation.nextSequence - 1 : 0,
+    part: continuation ? continuation.part + 1 : 1
   };
   if (cfg.sink.type === "file") {
     const baseDir = cfg.sink.baseDir;
@@ -2106,7 +2150,7 @@ async function startStreamingSession(session, agentRuntime) {
 }
 function recordTraceEvent(session, event) {
   if (!session) return void 0;
-  const sequence = session.events.length + 1;
+  const sequence = (session.sequenceOffset ?? 0) + session.events.length + 1;
   const id = generateEventId(sequence);
   const timestampIso = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
   const status = event.status ?? "success";
@@ -2296,7 +2340,8 @@ async function finalizeTraceSession(session, params = {}) {
     summary: session.summary,
     events: session.events,
     status: status2,
-    errors: session.errors
+    errors: session.errors,
+    ...(session.part ?? 1) > 1 ? { continuation: { part: session.part, firstSequence: (session.sequenceOffset ?? 0) + 1 } } : {}
   });
   const payloadForSink = buildPayload(initialStatus);
   let sinkFailed = false;
@@ -2353,7 +2398,17 @@ async function finalizeTraceSession(session, params = {}) {
   if (sink.type === "file" && session.fileSessionDir) {
     try {
       const filePath = path__default.default.join(session.fileSessionDir, "trace.session.json");
-      await fs__default.default.promises.writeFile(filePath, JSON.stringify(finalPayload, null, 2), "utf8");
+      let filePayload = finalPayload;
+      if (finalPayload.continuation) {
+        try {
+          const previous = JSON.parse(await fs__default.default.promises.readFile(filePath, "utf8"));
+          const earlier = (previous.events ?? []).filter((event) => event.sequence < finalPayload.continuation.firstSequence);
+          filePayload = { ...finalPayload, events: [...earlier, ...finalPayload.events] };
+          delete filePayload.continuation;
+        } catch {
+        }
+      }
+      await fs__default.default.promises.writeFile(filePath, JSON.stringify(filePayload, null, 2), "utf8");
     } catch (err) {
       sinkFailed = true;
       const message = err instanceof Error ? err.message : String(err);
@@ -4792,6 +4847,207 @@ ${append}`;
   };
 }
 
+// src/utils/traceDecisions.ts
+var TRACED_KEY = "__outcomeTraced";
+function waitedMs(from, to) {
+  if (!from || !to) return void 0;
+  const ms = Date.parse(to) - Date.parse(from);
+  return Number.isFinite(ms) && ms >= 0 ? ms : void 0;
+}
+function sameJson(a, b) {
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+}
+function recordApprovalRequested(session, entry) {
+  if (!session) return;
+  const logData = session.resolvedConfig.logData;
+  const sections = [
+    {
+      kind: "metadata",
+      label: "Approval",
+      data: {
+        approvalId: entry.id,
+        toolCallId: entry.toolCallId,
+        status: "pending",
+        requestedAt: entry.requestedAt,
+        ...entry.metadata?.prompt !== void 0 ? { prompt: entry.metadata.prompt } : {}
+      }
+    }
+  ];
+  if (logData) {
+    sections.push({ kind: "tool_call", label: "Arguments to approve", tool: entry.toolName, arguments: sanitizeTracePayload(entry.args) });
+  }
+  recordTraceEvent(session, {
+    type: "tool_approval",
+    label: `Approval requested \xB7 ${entry.toolName}`,
+    timestamp: entry.requestedAt,
+    status: "pending",
+    actor: { scope: "agent", name: entry.toolName, role: "approval_request" },
+    sections
+  });
+}
+function recordHumanDecisions(session, state) {
+  if (!session) return;
+  const logData = session.resolvedConfig.logData;
+  for (const entry of state.pendingApprovals ?? []) {
+    if (!entry.decidedAt || entry.metadata?.[TRACED_KEY]) continue;
+    if (entry.status !== "approved" && entry.status !== "rejected") continue;
+    const approved = entry.status === "approved";
+    const edited = approved && entry.approvedArgs !== void 0 && !sameJson(entry.approvedArgs, entry.args);
+    const sections = [
+      {
+        kind: "metadata",
+        label: "Decision",
+        data: {
+          approvalId: entry.id,
+          toolCallId: entry.toolCallId,
+          decision: entry.status,
+          ...entry.decidedBy ? { decidedBy: entry.decidedBy } : {},
+          ...entry.comment ? { comment: entry.comment } : {},
+          requestedAt: entry.requestedAt,
+          decidedAt: entry.decidedAt,
+          ...waitedMs(entry.requestedAt, entry.decidedAt) !== void 0 ? { waitedMs: waitedMs(entry.requestedAt, entry.decidedAt) } : {},
+          ...edited ? { argumentsEdited: true } : {}
+        }
+      }
+    ];
+    if (logData) {
+      sections.push({ kind: "tool_call", label: "Requested arguments", tool: entry.toolName, arguments: sanitizeTracePayload(entry.args) });
+      if (edited) {
+        sections.push({ kind: "tool_call", label: "Approved arguments", tool: entry.toolName, arguments: sanitizeTracePayload(entry.approvedArgs) });
+      }
+    }
+    recordTraceEvent(session, {
+      type: "tool_approval",
+      label: `${approved ? "Approved" : "Rejected"} \xB7 ${entry.toolName}`,
+      timestamp: entry.decidedAt,
+      durationMs: waitedMs(entry.requestedAt, entry.decidedAt),
+      status: "success",
+      actor: { scope: "human", name: entry.decidedBy || "reviewer", role: "approver" },
+      sections
+    });
+    entry.metadata = { ...entry.metadata || {}, [TRACED_KEY]: true };
+  }
+  for (const entry of state.pendingUserQuestions ?? []) {
+    if (!entry.answeredAt || entry.metadata?.[TRACED_KEY]) continue;
+    if (entry.status !== "answered" && entry.status !== "cancelled") continue;
+    const clientTool = readClientTool(entry);
+    if (clientTool) {
+      recordClientToolResult(session, entry, clientTool, state.toolHistory);
+      entry.metadata = { ...entry.metadata || {}, [TRACED_KEY]: true };
+      continue;
+    }
+    const cancelled = entry.status === "cancelled";
+    const data = {
+      questionId: entry.id,
+      toolCallId: entry.toolCallId,
+      status: entry.status,
+      ...entry.answeredBy ? { answeredBy: entry.answeredBy } : {},
+      ...entry.notes ? { notes: entry.notes } : {},
+      requestedAt: entry.requestedAt,
+      answeredAt: entry.answeredAt,
+      ...waitedMs(entry.requestedAt, entry.answeredAt) !== void 0 ? { waitedMs: waitedMs(entry.requestedAt, entry.answeredAt) } : {}
+    };
+    const sections = [{ kind: "metadata", label: "Answer", data }];
+    if (logData) {
+      sections.push({
+        kind: "metadata",
+        label: "Questions and answers",
+        data: {
+          items: (entry.questions ?? []).map((item) => ({
+            question: item.question,
+            ...item.header ? { header: item.header } : {},
+            answer: sanitizeTracePayload(entry.answers?.[item.question] ?? (item.header ? entry.answers?.[item.header] : void 0) ?? null)
+          }))
+        }
+      });
+    }
+    recordTraceEvent(session, {
+      type: "user_question",
+      label: cancelled ? "Question cancelled" : "Answer from user",
+      timestamp: entry.answeredAt,
+      durationMs: waitedMs(entry.requestedAt, entry.answeredAt),
+      status: cancelled ? "skipped" : "success",
+      actor: { scope: "human", name: entry.answeredBy || "user", role: "user" },
+      sections
+    });
+    entry.metadata = { ...entry.metadata || {}, [TRACED_KEY]: true };
+  }
+}
+function recordClientToolRequested(session, entry) {
+  if (!session) return;
+  const clientTool = readClientTool(entry);
+  if (!clientTool) return;
+  const sections = [
+    {
+      kind: "metadata",
+      label: "Client tool",
+      data: { questionId: entry.id, toolCallId: entry.toolCallId, status: "pending", requestedAt: entry.requestedAt }
+    }
+  ];
+  if (session.resolvedConfig.logData) {
+    sections.push({ kind: "tool_call", label: "Arguments", tool: clientTool.name, arguments: sanitizeTracePayload(clientTool.args) });
+  }
+  recordTraceEvent(session, {
+    type: "tool_call",
+    label: `Tool Execution - ${clientTool.name} (client)`,
+    timestamp: entry.requestedAt,
+    status: "pending",
+    actor: { scope: "client", name: clientTool.name, role: "tool" },
+    sections
+  });
+}
+function readClientTool(entry) {
+  const meta = entry.metadata?.clientTool;
+  if (!meta || typeof meta !== "object" || typeof meta.name !== "string") return void 0;
+  return { name: meta.name, args: meta.args };
+}
+function recordClientToolResult(session, entry, clientTool, toolHistory) {
+  const step = [...toolHistory ?? []].reverse().find((item) => item?.tool_call_id === entry.toolCallId);
+  const failed = step?.status === "error" || entry.status === "cancelled";
+  const sections = [
+    {
+      kind: "metadata",
+      label: "Client tool",
+      data: {
+        questionId: entry.id,
+        toolCallId: entry.toolCallId,
+        status: failed ? "error" : "answered",
+        ...entry.answeredBy ? { answeredBy: entry.answeredBy } : {},
+        requestedAt: entry.requestedAt,
+        answeredAt: entry.answeredAt,
+        ...waitedMs(entry.requestedAt, entry.answeredAt) !== void 0 ? { waitedMs: waitedMs(entry.requestedAt, entry.answeredAt) } : {}
+      }
+    }
+  ];
+  if (session.resolvedConfig.logData) {
+    sections.push({ kind: "tool_call", label: "Arguments", tool: clientTool.name, arguments: sanitizeTracePayload(clientTool.args) });
+    if (step) {
+      const output = step.rawOutput ?? step.output;
+      sections.push({
+        kind: "tool_result",
+        label: "Result from client",
+        tool: clientTool.name,
+        output: sanitizeTracePayload(output),
+        summary: typeof step.output === "string" ? step.output.slice(0, 2e3) : void 0
+      });
+    }
+  }
+  const ranMs = typeof step?.durationMs === "number" ? step.durationMs : void 0;
+  recordTraceEvent(session, {
+    type: "tool_call",
+    label: `Tool Execution - ${clientTool.name} (client)`,
+    timestamp: entry.answeredAt,
+    durationMs: waitedMs(entry.requestedAt, entry.answeredAt) ?? ranMs,
+    status: failed ? "error" : "success",
+    actor: { scope: "client", name: clientTool.name, role: "tool" },
+    sections
+  });
+}
+
 // src/utils/traceSections.ts
 init_content();
 function truncate(text, max = 500) {
@@ -5105,10 +5361,10 @@ function createToolsNode(initialTools, opts) {
       const toolCallId = tc.id || `${tc.name}_${toolCount + 1}`;
       const validatedArgs = validateToolArgs(tool, args);
       if (!validatedArgs.ok && resolved.toolResponses.schemaValidation === "strict") {
-        const errorMessage = `Tool argument validation failed for ${tc.name}: ${validatedArgs.message}`;
-        push({ role: "tool", content: errorMessage, tool_call_id: toolCallId, name: tc.name });
-        markToolFailure(errorMessage, tc.name, toolCallId);
-        onEvent?.({ type: "tool_call", phase: "error", name: tc.name, id: tc.id, args, error: { message: errorMessage } });
+        const errorMessage2 = `Tool argument validation failed for ${tc.name}: ${validatedArgs.message}`;
+        push({ role: "tool", content: errorMessage2, tool_call_id: toolCallId, name: tc.name });
+        markToolFailure(errorMessage2, tc.name, toolCallId);
+        onEvent?.({ type: "tool_call", phase: "error", name: tc.name, id: tc.id, args, error: { message: errorMessage2 } });
         toolCount += 1;
         return { status: "error" };
       }
@@ -5260,6 +5516,7 @@ function createToolsNode(initialTools, opts) {
           };
           pendingApprovals.push(approvalEntry);
           pendingByCallId.set(toolCallId, approvalEntry);
+          recordApprovalRequested(traceSession, approvalEntry);
           onEvent?.({ type: "tool_approval", status: "pending", id: approvalEntry.id, toolName: approvalEntry.toolName, toolCallId: approvalEntry.toolCallId, args });
           if (host?.has("notification")) {
             await host.runObservers("notification", {
@@ -5523,6 +5780,7 @@ function createToolsNode(initialTools, opts) {
           if (!pendingApproval) {
             throw new Error(`Tool ${toolName} requested approval but no pending approval entry was recorded.`);
           }
+          recordApprovalRequested(traceSession, pendingApproval);
           awaitingApproval = true;
           return {
             status: "awaiting_approval",
@@ -5539,6 +5797,7 @@ function createToolsNode(initialTools, opts) {
           if (!pendingQuestion) {
             throw new Error(`Tool ${toolName} requested a user question but no pending question entry was recorded.`);
           }
+          recordClientToolRequested(traceSession, pendingQuestion);
           awaitingUserQuestion = true;
           if (host?.has("notification")) {
             await host.runObservers("notification", {
@@ -6119,7 +6378,7 @@ var LEVEL_DEFAULTS = {
 };
 var VALID_LEVELS = ["minimal", "low", "medium", "high"];
 var VALID_CADENCES = ["off", "every_turn", "after_tool", "on_branch", "initial_then_after_tool"];
-var VALID_EFFORTS = ["none", "minimal", "low", "medium", "high"];
+var VALID_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 function validateReasoningConfig(input) {
   if (!input) return;
   if (input.level !== void 0 && !VALID_LEVELS.includes(input.level)) {
@@ -6635,16 +6894,20 @@ function createAskUserQuestionTool(stateRef, config) {
       });
       recordTraceEvent(ctx.__traceSession, {
         type: "user_question",
-        label: "Ask User",
+        label: "Question to user",
+        timestamp: entry.requestedAt,
         actor: { scope: "agent", name: "ask_user_question", role: "user_interaction" },
-        status: "success",
+        status: "pending",
         sections: [
           {
             kind: "metadata",
             label: "Pending Question",
             data: {
               id: entry.id,
+              questionId: entry.id,
               toolCallId: entry.toolCallId,
+              status: "pending",
+              requestedAt: entry.requestedAt,
               questions: entry.questions,
               allowFreeText
             }
@@ -7863,15 +8126,17 @@ function createAgent(opts) {
       }
       const traceSession = state.ctx?.__traceSession;
       if (traceSession) {
+        const iterationNumber = (traceSession.summary.eventCounts.agent_iteration ?? 0) + 1;
         const iterEvent = recordTraceEvent(traceSession, {
           type: "agent_iteration",
-          label: `Iteration ${iterations}`,
+          label: `Iteration ${iterationNumber}`,
           actor: { scope: "agent", name: opts.name || "agent", role: "orchestrator" },
           parentSpanId: traceSession.rootSpanId
         });
         if (iterEvent) {
           traceSession.currentIterationSpanId = iterEvent.spanId;
         }
+        recordHumanDecisions(traceSession, state);
       }
       if (cancelIfRequested("loop")) break;
       const skippingAgent = resumeStage === "tools";
@@ -8152,7 +8417,7 @@ function createAgent(opts) {
       }
       emit({ type: "progress", ...progress });
     };
-    const traceSession = createTraceSession(opts);
+    const traceSession = createTraceSession(opts, readTraceContinuation(input.ctx?.__traceContinuation));
     const ctx = {
       ...input.ctx || {},
       __onEvent: onEvent,
@@ -8160,6 +8425,7 @@ function createAgent(opts) {
       __onStream: onStream,
       __streaming: streamEnabled
     };
+    delete ctx.__traceContinuation;
     if (traceSession) ctx.__traceSession = traceSession;
     delete ctx.__plugins;
     delete ctx.__applySystemPromptContribution;
@@ -8308,10 +8574,17 @@ function createAgent(opts) {
         }
       }
     }
+    const pausedForHuman = statusFor(res) === "paused";
+    const midTurn = pausedForHuman || Boolean(res.ctx?.__needsSummarization);
     await finalizeTraceSession(traceSession, {
       agentRuntime: res.agent || runtime,
-      status: "success"
+      status: pausedForHuman ? "paused" : midTurn ? "in_progress" : "success"
     });
+    if (traceSession && midTurn) {
+      res.ctx = { ...res.ctx || {}, __traceContinuation: traceContinuationOf(traceSession) };
+    } else if (res.ctx && "__traceContinuation" in res.ctx) {
+      delete res.ctx.__traceContinuation;
+    }
     const isTransientSummarizationExit = !!res.ctx?.__needsSummarization;
     const finalAssistantMsg = isTransientSummarizationExit ? void 0 : getLastAssistantMessage(res.messages);
     const finalIsSyntheticSummary = !isTransientSummarizationExit && finalAssistantMsg && isSyntheticSummaryMessage(finalAssistantMsg);
@@ -11215,6 +11488,14 @@ ${pluginAppend}`;
         } else if (lastResult.state) {
           lastResult = { ...lastResult, state: { ...lastResult.state, memoryFacts: state.memoryFacts, plan: state.plan, planVersion: state.planVersion, messages: rawMessages } };
         }
+        if (lastResult.state) {
+          const endCtx = lastResult.state.ctx;
+          if (endCtx?.__traceContinuation && !(endCtx.__awaitingApproval || endCtx.__awaitingUserQuestion || endCtx.__paused)) {
+            const strippedCtx = { ...endCtx };
+            delete strippedCtx.__traceContinuation;
+            lastResult = { ...lastResult, state: { ...lastResult.state, ctx: strippedCtx } };
+          }
+        }
         if (skillsEnabled && lastResult.state) {
           const persisted = skillStateFromRegistry(toolSet.skillRegistryRef);
           if (persisted) {
@@ -11589,6 +11870,7 @@ var BaseProvider = class {
   /** Applies the transport options shared by every provider config. */
   configureTransport(config) {
     this.fetchImpl = config.fetch;
+    this.onModelRuleLearned = config.onModelRuleLearned;
     this.timeoutMs = typeof config.timeoutMs === "number" && config.timeoutMs > 0 ? config.timeoutMs : void 0;
   }
   /**
@@ -15256,32 +15538,805 @@ function languageGuard(config) {
 // src/index.ts
 init_content();
 
+// src/models/model-rules.json
+var model_rules_default = {
+  version: 1,
+  effortLadder: [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max"
+  ],
+  budgets: {
+    minimal: 1024,
+    low: 2048,
+    medium: 8192,
+    high: 16384,
+    xhigh: 24576,
+    max: 32768
+  },
+  geminiBudgets: {
+    minimal: 512,
+    low: 1024,
+    medium: 4096,
+    high: 12e3,
+    xhigh: 24576,
+    max: 24576
+  },
+  rules: [
+    {
+      id: "openai-chat-models",
+      family: "openai",
+      match: "^(?:chatgpt|gpt-[\\d.]+[a-z0-9.-]*?-chat)",
+      reasoning: {
+        style: "none",
+        efforts: [],
+        off: null
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_completion_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Chat-tuned *-chat variants are not reasoning models: ordinary sampling, no reasoning field."
+    },
+    {
+      id: "openai-gpt-6-plus",
+      family: "openai",
+      match: "^gpt-?(?:[6-9]|(?!35(?!\\d))[1-9]\\d+)(?:[.-]|$)",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "none",
+          "low",
+          "medium",
+          "high",
+          "xhigh"
+        ],
+        off: "none",
+        responsesEfforts: [
+          "none",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ]
+      },
+      sampling: {
+        temperature: "default-only",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_completion_tokens",
+      chatTools: {
+        reasoning: "force-none"
+      },
+      source: "verified-2026-10-14",
+      note: "gpt-N, N>=6. Chat Completions takes none/low/medium/high/xhigh (minimal and max are 400s); Responses also takes max. Function tools with an effort other than none are a 400 on Chat Completions and the default effort is not none, so none is sent explicitly. Rejects max_tokens, temperature != 1, top_p, penalties, logprobs."
+    },
+    {
+      id: "openai-gpt-5x",
+      family: "openai",
+      match: "^gpt-?5\\.[1-9]",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "none",
+          "low",
+          "medium",
+          "high",
+          "xhigh"
+        ],
+        off: "none",
+        responsesEfforts: [
+          "none",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ]
+      },
+      sampling: {
+        temperature: "default-only",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_completion_tokens",
+      chatTools: {
+        reasoning: "force-none"
+      },
+      source: "verified-2026-10-14",
+      note: "gpt-5.1 and newer 5.x. Same wire rules as gpt-6: no minimal/max on Chat Completions (Responses takes max), function tools need reasoning_effort none on Chat Completions."
+    },
+    {
+      id: "openai-gpt-5-base",
+      family: "openai",
+      match: "^gpt-?5(?![.\\d])",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "minimal",
+          "low",
+          "medium",
+          "high"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "default-only",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_completion_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "gpt-5, -mini, -nano, -codex: minimal/low/medium/high, reasoning cannot be turned off (none maps to minimal)."
+    },
+    {
+      id: "openai-o-series",
+      family: "openai",
+      match: "^o[1-9]\\d?(?![a-z0-9])",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "low",
+          "medium",
+          "high"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "default-only",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_completion_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "o1/o3/o4 family: low/medium/high, no sampling overrides."
+    },
+    {
+      id: "openai-gpt-oss",
+      family: "openai",
+      match: "^gpt-?oss",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "low",
+          "medium",
+          "high"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Open-weight gpt-oss: low/medium/high; sampling and max_tokens behave like an ordinary chat model."
+    },
+    {
+      id: "openai-legacy-gpt",
+      family: "openai",
+      match: "^(?:gpt-?(?:[0-4]|35)(?![0-9])|text-|davinci|babbage)",
+      reasoning: {
+        style: "none",
+        efforts: [],
+        off: null
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "gpt-4o, gpt-4.1, gpt-3.5 and older: no reasoning, ordinary sampling."
+    },
+    {
+      id: "openai-compatible-toggle",
+      family: "openai",
+      match: "^(?:deepseek-(?:r\\d|reasoner)|qwq|qwen-?3)",
+      reasoning: {
+        style: "toggle",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "none"
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "DeepSeek R/reasoner, QwQ, Qwen3: on/off style hosts. The effort is forwarded as-is (including none, which switches thinking off on thinking-by-default models)."
+    },
+    {
+      id: "openai-default",
+      family: "openai",
+      match: ".*",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "none"
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Permissive default for unknown OpenAI-wire models: pass what the caller asked; the provider learns from 400s."
+    },
+    {
+      id: "claude-haiku-5",
+      family: "anthropic",
+      match: "^claude-(?:haiku-5|5(?:-\\d+)?-haiku)(?!\\d)",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "disabled"
+      },
+      sampling: {
+        temperature: "unsupported",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "verified-2026-10-14",
+      note: "Claude Haiku 5.x: thinking:{type:adaptive} + output_config.effort; thinking:{type:enabled,budget_tokens} is rejected. Off = thinking:{type:disabled}. Sampling params are rejected."
+    },
+    {
+      id: "claude-sonnet-5",
+      family: "anthropic",
+      match: "^claude-(?:sonnet-5|5(?:-\\d+)?-sonnet)(?!\\d)",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "between_tools"
+      },
+      sampling: {
+        temperature: "unsupported",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "verified-2026-10-14",
+      note: "Claude Sonnet 5.x: adaptive + output_config.effort. thinking:{type:disabled} is rejected; off = thinking:{type:between_tools}. Sampling params are rejected."
+    },
+    {
+      id: "claude-opus-5",
+      family: "anthropic",
+      match: "^claude-(?:opus-5|5(?:-\\d+)?-opus)(?!\\d)",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "unsupported",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "verified-2026-10-14",
+      note: "Claude Opus 5.x: adaptive + output_config.effort; thinking cannot be turned off (none maps to the lowest effort). Sampling params are rejected."
+    },
+    {
+      id: "claude-fable",
+      family: "anthropic",
+      match: "^claude-fable",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "unsupported",
+        topP: false,
+        topK: false,
+        penalties: false,
+        logprobs: false
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Claude Fable line: treated like the 5.x adaptive models."
+    },
+    {
+      id: "claude-4-7",
+      family: "anthropic",
+      match: "^claude-(?:(?:opus|sonnet|haiku)-4[-.]7|4[-.]7-(?:opus|sonnet|haiku))(?!\\d)",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "disabled"
+      },
+      sampling: {
+        temperature: "thinking-requires-1",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Claude 4.7: adaptive thinking, low/medium/high/xhigh/max."
+    },
+    {
+      id: "claude-4-6",
+      family: "anthropic",
+      match: "^claude-(?:(?:opus|sonnet|haiku)-4[-.]6|4[-.]6-(?:opus|sonnet|haiku))(?!\\d)",
+      reasoning: {
+        style: "adaptive",
+        efforts: [
+          "low",
+          "medium",
+          "high",
+          "max"
+        ],
+        off: "disabled"
+      },
+      sampling: {
+        temperature: "thinking-requires-1",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Claude 4.6: adaptive thinking, low/medium/high/max (no xhigh)."
+    },
+    {
+      id: "claude-legacy-budget",
+      family: "anthropic",
+      match: "^claude-(?:3|4-|(?:opus|sonnet|haiku)-4)",
+      reasoning: {
+        style: "budget",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "thinking-requires-1",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Claude 3.7 and 4.0-4.5: thinking:{type:enabled,budget_tokens}; every effort maps to a budget; sampling overrides are not allowed while thinking."
+    },
+    {
+      id: "anthropic-default",
+      family: "anthropic",
+      match: ".*",
+      reasoning: {
+        style: "budget",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: null
+      },
+      sampling: {
+        temperature: "thinking-requires-1",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Permissive default for unknown Anthropic-wire models: budget style (the long-standing form); the provider flips the thinking form when the API says so."
+    },
+    {
+      id: "gemini-budget",
+      family: "gemini",
+      match: "^gemini",
+      reasoning: {
+        style: "budget",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "none"
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Gemini 2.5-style thinkingBudget; effort maps to a token budget, none = budget 0."
+    },
+    {
+      id: "gemini-default",
+      family: "gemini",
+      match: ".*",
+      reasoning: {
+        style: "budget",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "none"
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Permissive default for unknown Gemini-wire models."
+    },
+    {
+      id: "other-default",
+      family: "other",
+      match: ".*",
+      reasoning: {
+        style: "effort",
+        efforts: [
+          "none",
+          "minimal",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max"
+        ],
+        off: "none"
+      },
+      sampling: {
+        temperature: "any",
+        topP: true,
+        topK: true,
+        penalties: true,
+        logprobs: true
+      },
+      maxTokensParam: "max_tokens",
+      chatTools: {
+        reasoning: "any"
+      },
+      source: "docs",
+      note: "Permissive default for model families the SDK has no rules for."
+    }
+  ]
+};
+
+// src/models/rules.ts
+var MODEL_RULES = model_rules_default;
+var LADDER = MODEL_RULES.effortLadder;
+var compiled = /* @__PURE__ */ new Map();
+function regexFor(rule) {
+  let re = compiled.get(rule.id);
+  if (!re) {
+    re = new RegExp(rule.match, "i");
+    compiled.set(rule.id, re);
+  }
+  return re;
+}
+var GATEWAY_PREFIX = /^(?:(?:global|us|eu|apac|jp|au|ca|us-gov)\.)?(?:(?:openai|anthropic|google|meta|amazon|deepseek|qwen|mistral|cohere|ai21)\.)?/;
+function modelIdCandidates(model) {
+  if (!model) return [];
+  const lower = String(model).trim().toLowerCase();
+  const last = lower.split("/").pop() ?? lower;
+  const out = [];
+  for (const id of [lower, last]) {
+    for (const c of [id, id.replace(GATEWAY_PREFIX, "")]) {
+      if (c && !out.includes(c)) out.push(c);
+    }
+  }
+  return out;
+}
+var OPENAI_WIRE = /* @__PURE__ */ new Set(["openai", "azure", "openai-compatible", "together", "openrouter", "groq", "fireworks", "ollama", "vllm", "litellm", "mistral", "deepseek", "xai", "jev"]);
+function familiesFor(provider) {
+  const p = (provider ?? "").toLowerCase();
+  if (OPENAI_WIRE.has(p)) return ["openai"];
+  if (p === "anthropic") return ["anthropic"];
+  if (p === "bedrock") return ["anthropic", "openai", "other"];
+  if (p === "vertex" || p === "gemini" || p === "google") return ["gemini", "anthropic"];
+  return ["openai", "anthropic", "gemini", "other"];
+}
+function matchRule(family, ids, allowDefault) {
+  for (const rule of MODEL_RULES.rules) {
+    if (rule.family !== family) continue;
+    if (rule.match === ".*") {
+      if (allowDefault) return rule;
+      continue;
+    }
+    const re = regexFor(rule);
+    if (ids.some((id) => re.test(id))) return rule;
+  }
+  return void 0;
+}
+function mergeRulePatch(base, patch) {
+  if (!patch) return base;
+  const out = { ...base };
+  if (patch.reasoning) out.reasoning = { ...base.reasoning ?? {}, ...patch.reasoning };
+  if (patch.sampling) out.sampling = { ...base.sampling ?? {}, ...patch.sampling };
+  if (patch.chatTools) out.chatTools = { ...base.chatTools ?? {}, ...patch.chatTools };
+  if (patch.maxTokensParam) out.maxTokensParam = patch.maxTokensParam;
+  if (patch.dropParams) out.dropParams = [.../* @__PURE__ */ new Set([...base.dropParams ?? [], ...patch.dropParams])];
+  return out;
+}
+var LEARNED_MAX = 500;
+var learned = /* @__PURE__ */ new Map();
+function learnedKey(provider, model, scope) {
+  return `${(provider ?? "").toLowerCase()}@${scope ?? ""}::${(model ?? "").trim().toLowerCase()}`;
+}
+function rememberModelRulePatch(provider, model, patch, scope) {
+  const key = learnedKey(provider, model, scope);
+  const merged = mergeRulePatch(learned.get(key)?.patch ?? {}, patch);
+  learned.delete(key);
+  learned.set(key, { provider: provider.toLowerCase(), model: model.trim().toLowerCase(), scope, patch: merged });
+  if (learned.size > LEARNED_MAX) learned.delete(learned.keys().next().value);
+}
+function getLearnedModelRulePatch(provider, model, scope) {
+  return learned.get(learnedKey(provider, model, scope))?.patch;
+}
+function listLearnedModelRules() {
+  return [...learned.values()].map((e) => ({ ...e }));
+}
+function clearLearnedModelRules() {
+  learned.clear();
+}
+function resolveModelRule(opts) {
+  const families = familiesFor(opts.provider);
+  const ids = modelIdCandidates(opts.model);
+  let rule;
+  for (const family of families) {
+    rule = matchRule(family, ids, false);
+    if (rule) break;
+  }
+  let isDefault = false;
+  if (!rule) {
+    isDefault = true;
+    rule = matchRule(families[0], ids, true) ?? MODEL_RULES.rules[MODEL_RULES.rules.length - 1];
+  }
+  let effective = rule;
+  const known = opts.model ? learned.get(learnedKey(opts.provider, opts.model, opts.scope))?.patch : void 0;
+  if (known) effective = mergeRulePatch(effective, known);
+  if (opts.patch) effective = mergeRulePatch(effective, opts.patch);
+  return { ...effective, matchedRuleId: rule.id, isDefault, learned: !!known };
+}
+function mapReasoningEffort(rule, effort, endpoint = "chat") {
+  const efforts = endpoint === "responses" && rule.reasoning.responsesEfforts || rule.reasoning.efforts;
+  if (rule.reasoning.style === "none" || efforts.length === 0) return { mapped: true };
+  const supported = LADDER.filter((e) => efforts.includes(e));
+  if (supported.includes(effort)) return { effort, mapped: false };
+  if (effort === "none") {
+    const off = rule.reasoning.off;
+    if (off && off !== "none") return { off, mapped: true };
+    const lowest = supported.find((e) => e !== "none");
+    return lowest ? { effort: lowest, mapped: true } : { mapped: true };
+  }
+  const at = LADDER.indexOf(effort);
+  if (at < 0) return { mapped: true };
+  for (let i = at - 1; i >= 1; i--) if (supported.includes(LADDER[i])) return { effort: LADDER[i], mapped: true };
+  for (let i = at + 1; i < LADDER.length; i++) if (supported.includes(LADDER[i])) return { effort: LADDER[i], mapped: true };
+  return supported.includes("none") ? { effort: "none", mapped: true } : { mapped: true };
+}
+function allowsSampling(rule, field, value, thinkingOn = false) {
+  const s = rule.sampling;
+  switch (field) {
+    case "temperature":
+      switch (s.temperature) {
+        case "any":
+          return true;
+        case "unsupported":
+          return false;
+        // The default is what the server applies anyway, so it is never sent.
+        case "default-only":
+          return false;
+        case "thinking-requires-1":
+          return !thinkingOn || value === 1;
+      }
+      return true;
+    // Anthropic's thinking restriction covers top_p / top_k as well as temperature.
+    case "topP":
+      return s.topP && !(thinkingOn && s.temperature === "thinking-requires-1");
+    case "topK":
+      return s.topK && !(thinkingOn && s.temperature === "thinking-requires-1");
+    case "presencePenalty":
+    case "frequencyPenalty":
+      return s.penalties;
+    case "logprobs":
+      return s.logprobs;
+  }
+}
+function applyDropParams(body, rule) {
+  for (const p of rule.dropParams ?? []) {
+    const dot = p.indexOf(".");
+    if (dot < 0) delete body[p];
+    else if (body[p.slice(0, dot)] && typeof body[p.slice(0, dot)] === "object") delete body[p.slice(0, dot)][p.slice(dot + 1)];
+  }
+}
+function effortBudget(effort, table = "anthropic") {
+  if (effort === "none") return 0;
+  return (table === "gemini" ? MODEL_RULES.geminiBudgets : MODEL_RULES.budgets)[effort] ?? 0;
+}
+
 // src/providers/utils/reasoning.ts
 var ANTHROPIC_EFFORT_BUDGET = {
   // 0 = off. `applyAnthropicReasoning` bails on a falsy budget and emits no
   // thinking block, which on Anthropic IS off — thinking there is opt-in.
   none: 0,
-  minimal: 1024,
-  low: 2048,
-  medium: 8192,
-  high: 16384
+  ...MODEL_RULES.budgets
 };
 var GEMINI_EFFORT_BUDGET = {
   // 0 is Gemini's own documented spelling for "do not think", and unlike
   // Anthropic it has to be SENT — hence `applyGeminiReasoning` testing for null
   // rather than falsiness.
   none: 0,
-  minimal: 512,
-  low: 1024,
-  medium: 4096,
-  high: 12e3
+  ...MODEL_RULES.geminiBudgets
 };
 var THINKING_OUTPUT_RESERVE = 1024;
 var MIN_THINKING_BUDGET = 1024;
 var THINKING_MIN_MAX_TOKENS = 4096;
-function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
+function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort", model, rule) {
   if (!reasoning) return;
-  const effort = normalizeEffort(reasoning.effort);
+  const requested = normalizeEffort(reasoning.effort);
+  const r = rule ?? resolveModelRule({ provider: "openai", model: model ?? body.model });
+  const effort = requested && mapReasoningEffort(r, requested, mode === "responses" ? "responses" : "chat").effort;
   if (mode === "responses") {
     const obj = {};
     if (effort) obj.effort = effort;
@@ -15295,48 +16350,54 @@ function applyOpenAIReasoning(body, reasoning, mode = "legacy_effort") {
 }
 function supportsAdaptiveThinking(model) {
   if (typeof model !== "string") return false;
-  const id = model.toLowerCase();
-  const at = id.indexOf("claude-");
-  if (at < 0) return false;
-  for (const tok of id.slice(at + 7).split("-")) {
-    if (tok === "fable") return true;
-    const m = /^(\d+)(?:@|$)/.exec(tok);
-    if (m) {
-      if (m[1].length <= 2) return Number(m[1]) >= 5;
-      return false;
-    }
-  }
-  return false;
+  return resolveModelRule({ provider: "anthropic", model }).reasoning.style === "adaptive";
 }
-function resolveThinkingForm(model, mode) {
+function resolveThinkingForm(model, mode, rule) {
   if (mode === "adaptive" || mode === "budget") return mode;
+  if (rule) return rule.reasoning.style === "adaptive" ? "adaptive" : "budget";
   return supportsAdaptiveThinking(model) ? "adaptive" : "budget";
 }
-function applyAdaptiveThinking(_body, reasoning, setThinking, setOutputConfig) {
-  const requested = normalizeEffort(reasoning.effort);
-  if (requested === "none") return false;
-  let effort;
-  if (requested) effort = requested === "minimal" ? "low" : requested;
-  else if (typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
-    effort = reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.low ? "low" : reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.medium ? "medium" : "high";
+function enforceAnthropicSampling(target, rule, thinkingOn, bedrock = false) {
+  const fields = bedrock ? [["temperature", "temperature"], ["topP", "topP"]] : [["temperature", "temperature"], ["top_p", "topP"], ["top_k", "topK"]];
+  for (const [key, field] of fields) {
+    if (key in target && !allowsSampling(rule, field, target[key], thinkingOn)) delete target[key];
   }
-  if (!effort) return false;
+}
+function applyAdaptiveThinking(reasoning, rule, setThinking, setOutputConfig) {
+  let requested = normalizeEffort(reasoning.effort);
+  if (!requested && typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
+    requested = reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.low ? "low" : reasoning.budgetTokens <= ANTHROPIC_EFFORT_BUDGET.medium ? "medium" : "high";
+  }
+  if (!requested) return false;
+  const mapped = mapReasoningEffort(rule, requested);
+  if (mapped.off) {
+    setThinking({ type: mapped.off });
+    return false;
+  }
+  if (!mapped.effort || mapped.effort === "none") return false;
   const thinking = { type: "adaptive" };
   if (reasoning.includeThoughts !== false) thinking.display = "summarized";
   if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
-  setThinking({ thinking });
-  setOutputConfig({ effort });
+  setThinking(thinking);
+  setOutputConfig({ effort: mapped.effort });
   return true;
 }
 function applyAnthropicReasoning(body, reasoning, opts) {
-  if (!reasoning) return;
-  if (resolveThinkingForm(opts?.model ?? body.model, opts?.mode) === "adaptive") {
-    const on = applyAdaptiveThinking(body, reasoning, (extra) => body.thinking = extra.thinking, (o) => body.output_config = { ...body.output_config ?? {}, ...o });
-    if (on) stripSamplingParams(body, ["temperature", "top_p", "top_k"]);
+  const rule = opts?.rule ?? resolveModelRule({ provider: "anthropic", model: opts?.model ?? body.model });
+  if (!reasoning) {
+    enforceAnthropicSampling(body, rule, false);
+    return;
+  }
+  if (resolveThinkingForm(opts?.model ?? body.model, opts?.mode, rule) === "adaptive") {
+    const on = applyAdaptiveThinking(reasoning, rule, (t) => body.thinking = t, (o) => body.output_config = { ...body.output_config ?? {}, ...o });
+    enforceAnthropicSampling(body, rule, on);
+    return;
+  }
+  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET, rule);
+  if (!budget) {
+    enforceAnthropicSampling(body, rule, false);
     return;
   }
-  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
-  if (!budget) return;
   const currentMax = typeof body.max_tokens === "number" ? body.max_tokens : 0;
   const requiredMax = Math.max(THINKING_MIN_MAX_TOKENS, budget + THINKING_OUTPUT_RESERVE);
   if (currentMax < requiredMax) {
@@ -15346,18 +16407,25 @@ function applyAnthropicReasoning(body, reasoning, opts) {
   const thinking = { type: "enabled", budget_tokens: budget };
   if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
   body.thinking = thinking;
-  stripSamplingParams(body, ["temperature", "top_p", "top_k"]);
+  enforceAnthropicSampling(body, rule, true);
 }
 function applyBedrockReasoning(body, reasoning, opts) {
-  if (!reasoning) return;
-  if (resolveThinkingForm(opts?.model ?? body.modelId, opts?.mode) === "adaptive") {
+  const rule = opts?.rule ?? resolveModelRule({ provider: "bedrock", model: opts?.model ?? body.modelId });
+  if (!reasoning) {
+    if (body.inferenceConfig) enforceAnthropicSampling(body.inferenceConfig, rule, false, true);
+    return;
+  }
+  if (resolveThinkingForm(opts?.model ?? body.modelId, opts?.mode, rule) === "adaptive") {
     const fields = () => body.additionalModelRequestFields ?? (body.additionalModelRequestFields = {});
-    const on = applyAdaptiveThinking(body, reasoning, (extra2) => fields().thinking = extra2.thinking, (o) => fields().output_config = { ...fields().output_config ?? {}, ...o });
-    if (on && body.inferenceConfig) stripSamplingParams(body.inferenceConfig, ["temperature", "topP"]);
+    const on = applyAdaptiveThinking(reasoning, rule, (t) => fields().thinking = t, (o) => fields().output_config = { ...fields().output_config ?? {}, ...o });
+    if (body.inferenceConfig) enforceAnthropicSampling(body.inferenceConfig, rule, on, true);
+    return;
+  }
+  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET, rule);
+  if (!budget) {
+    if (body.inferenceConfig) enforceAnthropicSampling(body.inferenceConfig, rule, false, true);
     return;
   }
-  let budget = resolveBudget(reasoning, ANTHROPIC_EFFORT_BUDGET);
-  if (!budget) return;
   const inference = body.inferenceConfig ?? (body.inferenceConfig = {});
   const currentMax = typeof inference.maxTokens === "number" ? inference.maxTokens : 0;
   const requiredMax = Math.max(THINKING_MIN_MAX_TOKENS, budget + THINKING_OUTPUT_RESERVE);
@@ -15369,7 +16437,7 @@ function applyBedrockReasoning(body, reasoning, opts) {
   const thinking = { type: "enabled", budget_tokens: budget };
   if (reasoning.providerExtras) Object.assign(thinking, reasoning.providerExtras);
   extra.thinking = thinking;
-  stripSamplingParams(inference, ["temperature", "topP"]);
+  enforceAnthropicSampling(inference, rule, true, true);
 }
 function applyGeminiReasoning(generationConfig, reasoning) {
   if (!reasoning) return;
@@ -15381,11 +16449,6 @@ function applyGeminiReasoning(generationConfig, reasoning) {
   if (reasoning.providerExtras) Object.assign(thinkingConfig, reasoning.providerExtras);
   generationConfig.thinkingConfig = thinkingConfig;
 }
-function stripSamplingParams(target, keys) {
-  for (const k of keys) {
-    if (k in target) delete target[k];
-  }
-}
 function clampBudget(budget, maxTokens) {
   if (typeof maxTokens !== "number" || maxTokens <= 0) return budget;
   const ceiling = maxTokens - THINKING_OUTPUT_RESERVE;
@@ -15394,16 +16457,17 @@ function clampBudget(budget, maxTokens) {
 }
 function normalizeEffort(effort) {
   if (!effort) return void 0;
-  const allowed = ["none", "minimal", "low", "medium", "high"];
+  const allowed = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
   return allowed.includes(effort) ? effort : void 0;
 }
-function resolveBudget(reasoning, effortBudget) {
+function resolveBudget(reasoning, effortBudget2, rule) {
   const effort = normalizeEffort(reasoning.effort);
   if (effort === "none") return 0;
   if (typeof reasoning.budgetTokens === "number" && reasoning.budgetTokens > 0) {
     return Math.floor(reasoning.budgetTokens);
   }
-  if (effort && effortBudget[effort]) return effortBudget[effort];
+  const mapped = effort && rule ? mapReasoningEffort(rule, effort).effort : effort;
+  if (mapped && effortBudget2[mapped]) return effortBudget2[mapped];
   return void 0;
 }
 
@@ -15474,6 +16538,211 @@ function parseSSEBlock(block) {
   return { event, data: dataLines.join("\n"), id, retry };
 }
 
+// src/models/errors.ts
+var ModelRequestError = class extends ProviderError {
+  constructor(init) {
+    super(init.message, init.provider, init.status ?? 400, init.responseBody);
+    this.status = init.status ?? 400;
+    this.code = init.code;
+    this.param = init.param;
+    this.value = init.value;
+    this.supportedValues = init.supportedValues;
+    this.model = init.model;
+  }
+};
+
+// src/models/adjust.ts
+var MAX_ADJUSTMENTS = 3;
+var Q = "['\"`]";
+function errorMessage(text) {
+  try {
+    const j = JSON.parse(text);
+    const e = j?.error ?? j;
+    const message = typeof e?.message === "string" ? e.message : typeof j?.message === "string" ? j.message : text;
+    return { message, param: typeof e?.param === "string" ? e.param : void 0, code: typeof e?.code === "string" ? e.code : void 0 };
+  } catch {
+    return { message: text };
+  }
+}
+function quotedList(s) {
+  const quoted = [...s.matchAll(new RegExp(`${Q}([^'"\`]+)${Q}`, "g"))].map((m) => m[1]);
+  if (quoted.length > 0) return quoted;
+  return s.split(/[,\s]+/).map((x) => x.replace(/[.\s]+$/, "")).filter(Boolean);
+}
+function parseModelError(text) {
+  const { message, param: errParam } = errorMessage(String(text ?? ""));
+  const m = message.toLowerCase();
+  if (m.includes("function tools with reasoning_effort") && m.includes("not supported")) {
+    return { kind: "chat_tools_effort", message };
+  }
+  if (m.includes("between_tools") && m.includes("thinking")) return { kind: "thinking_off_between_tools", message };
+  if (m.includes("thinking.type.enabled") && m.includes("not supported")) return { kind: "thinking_enabled_unsupported", message };
+  if (m.includes("thinking.type.adaptive") && m.includes("not supported")) return { kind: "thinking_adaptive_unsupported", message };
+  if (m.includes("thinking.type.disabled") && m.includes("not supported")) return { kind: "thinking_disabled_unsupported", message };
+  const tt = new RegExp(`${Q}?(temperature|top_p|top_k)${Q}?\\s+may only be set to 1 when thinking is enabled`, "i").exec(message);
+  if (tt) return { kind: "temperature_thinking", param: tt[1].toLowerCase(), message };
+  const dep = new RegExp(`${Q}([\\w.]+)${Q}\\s+is deprecated for this model`, "i").exec(message);
+  if (dep) return { kind: "unsupported_parameter", param: dep[1], message };
+  const rename = new RegExp(`use ${Q}(max_completion_tokens|max_tokens)${Q} instead`, "i").exec(message);
+  if (rename) return { kind: "max_tokens_rename", renameTo: rename[1].toLowerCase(), param: rename[1].toLowerCase() === "max_tokens" ? "max_completion_tokens" : "max_tokens", message };
+  const val = new RegExp(`unsupported value:?\\s*${Q}?([\\w.]+)${Q}?\\s+does not support\\s+(${Q}[^'"\`]*${Q}|[^\\s]+)`, "i").exec(message);
+  if (val) {
+    const param = val[1];
+    const value = val[2].replace(/^['"`]|['"`]$/g, "");
+    if (m.includes("only the default") && m.includes("value is supported")) return { kind: "default_only", param, value, message };
+    const sup = /supported values? (?:are|is):?\s*([^\n]*)/i.exec(message);
+    return { kind: "unsupported_value", param, value, supportedValues: sup ? quotedList(sup[1]) : void 0, message };
+  }
+  if (m.includes("only the default") && m.includes("value is supported")) {
+    return { kind: "default_only", param: errParam ?? "temperature", message };
+  }
+  const prm = new RegExp(`unsupported parameter:?\\s*${Q}?([\\w.]+)${Q}?`, "i").exec(message);
+  if (prm) return { kind: "unsupported_parameter", param: prm[1], message };
+  return void 0;
+}
+var normParam = (p) => p.toLowerCase().replace(/[-\s]/g, "_");
+var LADDER2 = new Set(MODEL_RULES.effortLadder);
+function patchFromParsedError(parsed, endpoint = "chat") {
+  const param = parsed.param ? normParam(parsed.param) : "";
+  switch (parsed.kind) {
+    case "chat_tools_effort":
+      return { patch: { chatTools: { reasoning: "force-none" } }, adjustment: "chat-tools:force-effort-none" };
+    case "max_tokens_rename":
+      return { patch: { maxTokensParam: parsed.renameTo }, adjustment: `${parsed.param}->${parsed.renameTo}` };
+    case "thinking_enabled_unsupported":
+      return { patch: { reasoning: { style: "adaptive" } }, adjustment: "thinking:adaptive" };
+    case "thinking_adaptive_unsupported":
+      return { patch: { reasoning: { style: "budget" } }, adjustment: "thinking:budget" };
+    case "thinking_off_between_tools":
+      return { patch: { reasoning: { off: "between_tools" } }, adjustment: "thinking-off:between_tools" };
+    case "thinking_disabled_unsupported":
+      return { patch: { reasoning: { off: null } }, adjustment: "thinking-off:none" };
+    case "temperature_thinking":
+      return { patch: { sampling: { temperature: "unsupported" } }, adjustment: "drop:temperature" };
+    case "default_only":
+      if (param === "temperature") return { patch: { sampling: { temperature: "default-only" } }, adjustment: "temperature:default-only" };
+      return { patch: { dropParams: [parsed.param ?? param] }, adjustment: `drop:${parsed.param ?? param}` };
+    case "unsupported_value": {
+      if (/^(reasoning_effort|reasoning\.effort|effort|output_config\.effort)$/.test(param)) {
+        const list = (parsed.supportedValues ?? []).map((v) => v.toLowerCase()).filter((v) => LADDER2.has(v));
+        if (list.length === 0) return void 0;
+        const reasoning = endpoint === "responses" ? { responsesEfforts: list } : { efforts: list };
+        return { patch: { reasoning }, adjustment: `efforts:${list.join("|")}` };
+      }
+      return paramDropPatch(param, parsed);
+    }
+    case "unsupported_parameter":
+      return paramDropPatch(param, parsed);
+  }
+}
+function paramDropPatch(param, parsed) {
+  if (!param) return void 0;
+  const label = `drop:${parsed.param ?? param}`;
+  switch (param) {
+    case "temperature":
+      return { patch: { sampling: { temperature: "unsupported" } }, adjustment: label };
+    case "top_p":
+      return { patch: { sampling: { topP: false } }, adjustment: label };
+    case "top_k":
+      return { patch: { sampling: { topK: false } }, adjustment: label };
+    case "presence_penalty":
+    case "frequency_penalty":
+      return { patch: { sampling: { penalties: false } }, adjustment: label };
+    case "logprobs":
+    case "top_logprobs":
+      return { patch: { sampling: { logprobs: false } }, adjustment: label };
+    case "max_tokens":
+      return { patch: { maxTokensParam: "max_completion_tokens" }, adjustment: "max_tokens->max_completion_tokens" };
+    case "max_completion_tokens":
+      return { patch: { maxTokensParam: "max_tokens" }, adjustment: "max_completion_tokens->max_tokens" };
+    case "reasoning_effort":
+    case "reasoning.effort":
+    case "reasoning":
+      return { patch: { reasoning: { style: "none", efforts: [], responsesEfforts: [] }, dropParams: [param] }, adjustment: label };
+    default:
+      return { patch: { dropParams: [parsed.param ?? param] }, adjustment: label };
+  }
+}
+function codeFor(parsed) {
+  if (!parsed) return "model_request_invalid";
+  if (parsed.kind === "unsupported_value" || parsed.kind === "default_only") return "unsupported_value";
+  if (parsed.kind === "unsupported_parameter" || parsed.kind === "max_tokens_rename" || parsed.kind === "temperature_thinking") return "unsupported_parameter";
+  return "model_request_invalid";
+}
+function toModelRequestError(err, parsed, provider, model) {
+  return new ModelRequestError({
+    status: err.statusCode ?? 400,
+    code: codeFor(parsed),
+    param: parsed?.param,
+    value: parsed?.value,
+    supportedValues: parsed?.supportedValues,
+    provider: err.provider || provider,
+    model,
+    message: err.message,
+    responseBody: err.responseBody
+  });
+}
+var SameRequest = class extends Error {
+};
+function withoutCallerParams(step, callerParams) {
+  const drops = step.patch.dropParams;
+  if (!callerParams?.length || !drops) return step;
+  const mine = (p) => callerParams.includes(p.split(".")[0]);
+  if (!drops.some(mine)) return step;
+  const { dropParams: _ignored, ...rest } = step.patch;
+  const kept = drops.filter((p) => !mine(p));
+  const patch = kept.length ? { ...rest, dropParams: kept } : rest;
+  return Object.keys(patch).length ? { ...step, patch } : void 0;
+}
+async function runWithModelAdjustments(opts) {
+  let overlay = {};
+  const steps = [];
+  let previous;
+  let lastError;
+  let lastParsed;
+  for (; ; ) {
+    const guard = (body) => {
+      let json;
+      try {
+        json = JSON.stringify(body);
+      } catch {
+        return;
+      }
+      if (previous !== void 0 && json === previous) throw new SameRequest();
+      previous = json;
+    };
+    try {
+      const result = await opts.run(overlay, guard);
+      for (const step of steps) {
+        const s = withoutCallerParams(step, opts.callerParams);
+        if (!s) continue;
+        rememberModelRulePatch(opts.provider, opts.model, s.patch, opts.scope);
+        if (opts.onLearned) {
+          try {
+            opts.onLearned({ provider: opts.provider, model: opts.model, adjustment: s.adjustment, patch: s.patch, reason: s.reason });
+          } catch {
+          }
+        }
+      }
+      return result;
+    } catch (err) {
+      if (err instanceof SameRequest) throw toModelRequestError(lastError, lastParsed, opts.provider, opts.model);
+      if (!(err instanceof ProviderError) || err instanceof ModelRequestError || err.statusCode !== 400) throw err;
+      const parsed = parseModelError(String(err.responseBody ?? err.message));
+      const fix = parsed ? patchFromParsedError(parsed, opts.endpoint) : void 0;
+      lastError = err;
+      lastParsed = parsed;
+      if (!fix || steps.length >= MAX_ADJUSTMENTS) throw toModelRequestError(err, parsed, opts.provider, opts.model);
+      overlay = mergeRulePatch(overlay, fix.patch);
+      steps.push({ ...fix, reason: parsed.message });
+    }
+  }
+}
+function asModelRequestError(err, provider, model) {
+  if (!(err instanceof ProviderError) || err instanceof ModelRequestError || err.statusCode !== 400) return err;
+  return toModelRequestError(err, parseModelError(String(err.responseBody ?? err.message)), provider, model);
+}
+
 // src/providers/utils/media.ts
 var EXTENSION_MIME = {
   jpg: "image/jpeg",
@@ -15774,8 +17043,7 @@ var OpenAIProvider = class extends BaseProvider {
     if (this.useResponsesApi(request)) {
       return this.completeResponses(request);
     }
-    const body = this.buildRequestBody(request, false);
-    const res = await this.doFetch(body, request.signal);
+    const res = await this.fetchChat(request, false);
     const json = await res.json();
     return this.parseResponse(json);
   }
@@ -15799,8 +17067,7 @@ var OpenAIProvider = class extends BaseProvider {
       };
       return;
     }
-    const body = this.buildRequestBody(request, true);
-    const res = await this.doFetch(body, request.signal);
+    const res = await this.fetchChat(request, true);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
     let id = "";
     let model = "";
@@ -15904,7 +17171,43 @@ var OpenAIProvider = class extends BaseProvider {
     return res;
   }
   // ─── Internals ───────────────────────────────────────────────────────────
-  buildRequestBody(request, stream) {
+  /** Chat Completions call that corrects itself from the provider's own 400s (see models/adjust.ts). */
+  fetchChat(request, stream) {
+    const model = request.model || this.defaultModel;
+    return runWithModelAdjustments({
+      provider: this.providerName,
+      model,
+      endpoint: "chat",
+      scope: this.baseURL,
+      callerParams: request.extra ? Object.keys(request.extra) : void 0,
+      onLearned: this.onModelRuleLearned,
+      run: (overlay, guard) => {
+        const body = this.buildRequestBody(request, stream, overlay);
+        guard(body);
+        return this.doFetch(body, request.signal);
+      }
+    });
+  }
+  /** Same for the Responses API. */
+  fetchResponses(request, adaptExtras, stream = false) {
+    const model = request.model || this.defaultModel;
+    return runWithModelAdjustments({
+      provider: this.providerName,
+      model,
+      endpoint: "responses",
+      scope: this.baseURL,
+      callerParams: request.extra ? Object.keys(request.extra) : void 0,
+      onLearned: this.onModelRuleLearned,
+      run: (overlay, guard) => {
+        const body = this.buildResponsesBody(request, overlay);
+        if (adaptExtras) adaptChatExtrasForResponses(body, request.extra);
+        if (stream) body.stream = true;
+        guard(body);
+        return this.responsesFetch(body, request.signal);
+      }
+    });
+  }
+  buildRequestBody(request, stream, overlay) {
     const body = {
       model: request.model || this.defaultModel,
       messages: request.messages.map((m) => this.toOpenAIMessage(m)),
@@ -15914,20 +17217,20 @@ var OpenAIProvider = class extends BaseProvider {
       body.stream_options = { include_usage: true };
     }
     const modelId = String(body.model);
-    const reasoningModel = isReasoningModel(modelId) && !/chat/i.test(modelId);
-    if (request.temperature != null && !reasoningModel) body.temperature = request.temperature;
+    const rule = resolveModelRule({ provider: this.providerName, model: modelId, patch: overlay, scope: this.baseURL });
+    if (request.temperature != null && allowsSampling(rule, "temperature", request.temperature)) body.temperature = request.temperature;
     if (request.maxTokens != null) {
-      const useCompletionTokens = this.maxTokensParam === "max_completion_tokens" || this.maxTokensParam === "auto" && isReasoningModel(modelId);
-      body[useCompletionTokens ? "max_completion_tokens" : "max_tokens"] = request.maxTokens;
+      const param = this.maxTokensParam === "auto" ? rule.maxTokensParam : this.maxTokensParam;
+      body[param] = request.maxTokens;
     }
-    if (request.topP != null && !reasoningModel) body.top_p = request.topP;
+    if (request.topP != null && allowsSampling(rule, "topP")) body.top_p = request.topP;
     if (request.stop) body.stop = request.stop;
-    if (request.presencePenalty != null) body.presence_penalty = request.presencePenalty;
-    if (request.frequencyPenalty != null) body.frequency_penalty = request.frequencyPenalty;
+    if (request.presencePenalty != null && allowsSampling(rule, "presencePenalty")) body.presence_penalty = request.presencePenalty;
+    if (request.frequencyPenalty != null && allowsSampling(rule, "frequencyPenalty")) body.frequency_penalty = request.frequencyPenalty;
     if (request.seed != null) body.seed = request.seed;
     if (request.n != null) body.n = request.n;
-    if (request.logprobs != null) body.logprobs = request.logprobs;
-    if (request.topLogprobs != null) body.top_logprobs = request.topLogprobs;
+    if (request.logprobs != null && allowsSampling(rule, "logprobs")) body.logprobs = request.logprobs;
+    if (request.topLogprobs != null && allowsSampling(rule, "logprobs")) body.top_logprobs = request.topLogprobs;
     if (request.tools?.length) {
       body.tools = request.tools.map((t) => this.toOpenAITool(t));
       if (request.parallelToolCalls != null) body.parallel_tool_calls = request.parallelToolCalls;
@@ -15956,14 +17259,17 @@ var OpenAIProvider = class extends BaseProvider {
     if (request.extra) {
       Object.assign(body, request.extra);
     }
-    applyOpenAIReasoning(body, request.reasoning, "legacy_effort");
+    applyOpenAIReasoning(body, request.reasoning, "legacy_effort", modelId, rule);
+    if (body.tools?.length && rule.chatTools.reasoning === "force-none" && rule.reasoning.style !== "none") {
+      body.reasoning_effort = "none";
+    }
+    applyDropParams(body, rule);
     return body;
   }
   // ─── Responses API (reasoning models) ──────────────────────────────────────
   async completeResponses(request) {
-    const body = this.buildResponsesBody(request);
-    if (this.apiResponsesNative || this.isResponsesApiModel(request)) adaptChatExtrasForResponses(body, request.extra);
-    const res = await this.responsesFetch(body, request.signal);
+    const adapt = this.apiResponsesNative || this.isResponsesApiModel(request);
+    const res = await this.fetchResponses(request, adapt);
     const json = await res.json();
     return this.parseResponsesResponse(json, request.model || this.defaultModel);
   }
@@ -15976,10 +17282,7 @@ var OpenAIProvider = class extends BaseProvider {
    * reads it). */
   async *streamResponses(request) {
     const modelId = request.model || this.defaultModel;
-    const body = this.buildResponsesBody(request);
-    adaptChatExtrasForResponses(body, request.extra);
-    body.stream = true;
-    const res = await this.responsesFetch(body, request.signal);
+    const res = await this.fetchResponses(request, true, true);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
     let id = "";
     let model = modelId;
@@ -16068,13 +17371,14 @@ var OpenAIProvider = class extends BaseProvider {
       finishReason: final?.finishReason ?? (calls.size > 0 ? "tool_calls" : "stop")
     };
   }
-  buildResponsesBody(request) {
+  buildResponsesBody(request, overlay) {
     const body = {
       model: request.model || this.defaultModel,
       input: request.messages.map((m) => this.toResponsesInput(m))
     };
     if (request.maxTokens != null) body.max_output_tokens = request.maxTokens;
-    if (request.topP != null) body.top_p = request.topP;
+    const rule = resolveModelRule({ provider: this.providerName, model: String(body.model), patch: overlay, scope: this.baseURL });
+    if (request.topP != null && allowsSampling(rule, "topP")) body.top_p = request.topP;
     if (request.tools?.length) {
       body.tools = request.tools.map((t) => ({
         type: "function",
@@ -16106,7 +17410,8 @@ var OpenAIProvider = class extends BaseProvider {
       }
     }
     if (request.extra) Object.assign(body, request.extra);
-    applyOpenAIReasoning(body, request.reasoning, "responses");
+    applyOpenAIReasoning(body, request.reasoning, "responses", String(body.model), rule);
+    applyDropParams(body, rule);
     return body;
   }
   /** Maps a unified message to a Responses API `input` item. */
@@ -16371,8 +17676,8 @@ function pickProviderFields(top, message, choice) {
 }
 function isReasoningModel(model) {
   if (!model) return false;
-  const m = model.toLowerCase();
-  return /(^|[/_-])o[0-9]/.test(m) || m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4") || m.includes("gpt-5") || m.includes("gpt5");
+  const rule = resolveModelRule({ provider: "openai", model });
+  return !rule.isDefault && rule.reasoning.style === "effort" && rule.sampling.temperature !== "any";
 }
 function adaptChatExtrasForResponses(body, extra) {
   const native = extra ?? {};
@@ -16488,12 +17793,6 @@ function normalizeExplicitThinking(body) {
   }
   for (const k of ["temperature", "top_p", "top_k"]) delete body[k];
 }
-function thinkingFormRejected(text) {
-  const t = text.toLowerCase();
-  if (t.indexOf("thinking.type.enabled") >= 0 && t.indexOf("not supported") >= 0) return "enabled";
-  if (t.indexOf("thinking.type.adaptive") >= 0 && t.indexOf("not supported") >= 0 && t.indexOf("thinking.type.enabled") < 0) return "adaptive";
-  return void 0;
-}
 var AnthropicProvider = class extends BaseProvider {
   constructor(config) {
     super();
@@ -16644,7 +17943,7 @@ var AnthropicProvider = class extends BaseProvider {
     }
   }
   // ─── Internals ───────────────────────────────────────────────────────────
-  buildRequestBody(request, stream, modeOverride, downgradeToolChoice = false) {
+  buildRequestBody(request, stream, overlay, downgradeToolChoice = false) {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
       model: request.model || this.defaultModel,
@@ -16659,6 +17958,7 @@ var AnthropicProvider = class extends BaseProvider {
         body.system = system;
       }
     }
+    const rule = resolveModelRule({ provider: this.providerName, model: String(body.model), patch: overlay });
     if (request.temperature != null) body.temperature = request.temperature;
     if (request.topP != null) body.top_p = request.topP;
     if (request.stop) body.stop_sequences = request.stop;
@@ -16685,9 +17985,11 @@ var AnthropicProvider = class extends BaseProvider {
     const explicitThinking = request.extra && typeof request.extra === "object" && "thinking" in request.extra;
     if (explicitThinking) {
       normalizeExplicitThinking(body);
+      enforceAnthropicSampling(body, rule, body.thinking?.type === "enabled" || body.thinking?.type === "adaptive");
     } else {
-      applyAnthropicReasoning(body, request.reasoning, { model: body.model, mode: modeOverride ?? this.thinkingMode });
+      applyAnthropicReasoning(body, request.reasoning, { model: body.model, mode: this.thinkingMode, rule });
     }
+    applyDropParams(body, rule);
     if (typeof body.max_tokens !== "number" || !(body.max_tokens > 0)) {
       body.max_tokens = DEFAULT_MAX_TOKENS;
     }
@@ -16823,31 +18125,28 @@ var AnthropicProvider = class extends BaseProvider {
   }
   /** Builds and sends the request; retries once with the other thinking form
    * when the upstream rejects the one we picked. */
-  async send(request, stream) {
-    let mode;
+  send(request, stream) {
     let downgrade = false;
-    let flippedThinking = false;
-    for (; ; ) {
-      const body = this.buildRequestBody(request, stream, mode, downgrade);
-      try {
-        return await this.doFetch(body, request.signal);
-      } catch (err) {
-        if (!(err instanceof ProviderError) || err.statusCode !== 400) throw err;
-        const text = String(err.responseBody ?? err.message);
-        if (!downgrade && body.tool_choice && body.tool_choice.type !== "auto" && forcedToolChoiceRejected(text)) {
-          downgrade = true;
-          continue;
+    return runWithModelAdjustments({
+      provider: this.providerName,
+      model: request.model || this.defaultModel,
+      endpoint: "messages",
+      callerParams: request.extra ? Object.keys(request.extra) : void 0,
+      onLearned: this.onModelRuleLearned,
+      run: async (overlay, guard) => {
+        for (; ; ) {
+          const body = this.buildRequestBody(request, stream, overlay, downgrade);
+          guard(body);
+          try {
+            return await this.doFetch(body, request.signal);
+          } catch (err) {
+            const rejected = err instanceof ProviderError && err.statusCode === 400 && !downgrade && body.tool_choice && body.tool_choice.type !== "auto" && forcedToolChoiceRejected(String(err.responseBody ?? err.message));
+            if (!rejected) throw err;
+            downgrade = true;
+          }
         }
-        const explicit = request.extra && typeof request.extra === "object" && "thinking" in request.extra;
-        if (flippedThinking || explicit || !request.reasoning) throw err;
-        const wrong = thinkingFormRejected(text);
-        if (!wrong) throw err;
-        const used = resolveThinkingForm(request.model ?? this.defaultModel, this.thinkingMode);
-        if (wrong === "enabled" && used !== "budget" || wrong === "adaptive" && used !== "adaptive") throw err;
-        mode = wrong === "enabled" ? "adaptive" : "budget";
-        flippedThinking = true;
       }
-    }
+    });
   }
   async doFetch(body, signal) {
     const url = `${this.baseURL}/v1/messages`;
@@ -16964,6 +18263,7 @@ var AzureProvider = class extends OpenAIProvider {
       retry: config.retry,
       fetch: config.fetch,
       timeoutMs: config.timeoutMs,
+      onModelRuleLearned: config.onModelRuleLearned,
       maxTokensParam: config.maxTokensParam,
       api: config.api,
       responsesApi: config.responsesApi,
@@ -17092,6 +18392,7 @@ var OpenAICompatibleProvider = class extends OpenAIProvider {
       retry: config.retry,
       fetch: config.fetch,
       timeoutMs: config.timeoutMs,
+      onModelRuleLearned: config.onModelRuleLearned,
       maxTokensParam: config.maxTokensParam,
       api: config.api,
       // Unlike OpenAI / Azure, "auto" on a compatible server means Chat
@@ -17447,7 +18748,7 @@ var BedrockProvider = class extends BaseProvider {
     return res;
   }
   // ─── Internals ───────────────────────────────────────────────────────────
-  buildConverseBody(request, downgradeToolChoice = false) {
+  buildConverseBody(request, downgradeToolChoice = false, overlay) {
     const { system, messages } = this.splitSystemMessages(request.messages);
     const body = {
       messages: this.toBedrockMessages(messages)
@@ -17493,7 +18794,12 @@ var BedrockProvider = class extends BaseProvider {
       Object.assign(body, topLevel);
       if (Object.keys(fields).length > 0) body.additionalModelRequestFields = fields;
     }
-    applyBedrockReasoning(body, request.reasoning, { model: request.model || this.defaultModel, mode: this.thinkingMode });
+    const rule = resolveModelRule({ provider: this.providerName, model: request.model || this.defaultModel, patch: overlay });
+    applyBedrockReasoning(body, request.reasoning, { model: request.model || this.defaultModel, mode: this.thinkingMode, rule });
+    if (body.inferenceConfig && rule.dropParams?.length) {
+      for (const p of rule.dropParams) delete body.inferenceConfig[p === "top_p" ? "topP" : p === "max_tokens" ? "maxTokens" : p];
+    }
+    applyDropParams(body, rule);
     return body;
   }
   splitSystemMessages(messages) {
@@ -17618,16 +18924,29 @@ var BedrockProvider = class extends BaseProvider {
   }
   /** Sends the Converse call; retries once with toolChoice auto when the
    * model rejects forced tool use. */
-  async converseFetch(modelId, request, stream) {
-    const body = this.buildConverseBody(request);
-    try {
-      return await this.doFetch(modelId, body, request.signal, stream);
-    } catch (err) {
-      const tc = body.toolConfig?.toolChoice;
-      if (!(err instanceof ProviderError) || err.statusCode !== 400 || !tc || tc.auto) throw err;
-      if (!forcedToolChoiceRejected(String(err.responseBody ?? err.message))) throw err;
-      return this.doFetch(modelId, this.buildConverseBody(request, true), request.signal, stream);
-    }
+  converseFetch(modelId, request, stream) {
+    let downgrade = false;
+    return runWithModelAdjustments({
+      provider: this.providerName,
+      model: modelId,
+      endpoint: "converse",
+      callerParams: request.extra ? Object.keys(request.extra) : void 0,
+      onLearned: this.onModelRuleLearned,
+      run: async (overlay, guard) => {
+        for (; ; ) {
+          const body = this.buildConverseBody(request, downgrade, overlay);
+          guard(body);
+          try {
+            return await this.doFetch(modelId, body, request.signal, stream);
+          } catch (err) {
+            const tc = body.toolConfig?.toolChoice;
+            const rejected = err instanceof ProviderError && err.statusCode === 400 && !downgrade && !!tc && !tc.auto && forcedToolChoiceRejected(String(err.responseBody ?? err.message));
+            if (!rejected) throw err;
+            downgrade = true;
+          }
+        }
+      }
+    });
   }
   async doFetch(modelId, body, signal, stream) {
     const host = `bedrock-runtime.${this.region}.amazonaws.com`;
@@ -17817,7 +19136,7 @@ var VertexProvider = class extends BaseProvider {
     const modelId = request.model || this.defaultModel;
     const body = this.buildGeminiBody(request);
     const url = this.buildUrl(modelId, false);
-    const res = await this.doFetch(url, body, request.signal);
+    const res = await this.doFetch(url, body, request.signal, modelId);
     const json = await res.json();
     return this.parseResponse(json, modelId);
   }
@@ -17825,7 +19144,7 @@ var VertexProvider = class extends BaseProvider {
     const modelId = request.model || this.defaultModel;
     const body = this.buildGeminiBody(request);
     const url = this.buildUrl(modelId, true);
-    const res = await this.doFetch(url, body, request.signal);
+    const res = await this.doFetch(url, body, request.signal, modelId);
     if (!res.body) throw new ProviderError("No response body for stream", this.providerName);
     const counter = { next: 0 };
     const contentType = res.headers.get("content-type") ?? "";
@@ -17905,7 +19224,7 @@ var VertexProvider = class extends BaseProvider {
       };
       if (Object.keys(parameters).length > 0) body.parameters = parameters;
       Object.assign(body, extraRest);
-      const res = await this.doFetch(url, body, request.signal);
+      const res = await this.doFetch(url, body, request.signal, model);
       const json = await res.json();
       raw.push(json);
       for (const p of json.predictions ?? []) {
@@ -18128,7 +19447,7 @@ var VertexProvider = class extends BaseProvider {
     const tokenJson = await tokenRes.json();
     return tokenJson.access_token;
   }
-  async doFetch(url, body, signal) {
+  async doFetch(url, body, signal, model = "") {
     const token = await this.getAccessToken();
     const bodyStr = JSON.stringify(body);
     const res = await this.doFetchWithRetry(
@@ -18146,6 +19465,20 @@ var VertexProvider = class extends BaseProvider {
     );
     if (!res.ok) {
       const text = await res.text().catch(() => "");
+      if (res.status === 400) {
+        const parsed = parseModelError(text);
+        throw new ModelRequestError({
+          status: 400,
+          code: parsed?.kind === "unsupported_value" ? "unsupported_value" : parsed?.kind === "unsupported_parameter" ? "unsupported_parameter" : "model_request_invalid",
+          param: parsed?.param,
+          value: parsed?.value,
+          supportedValues: parsed?.supportedValues,
+          provider: this.providerName,
+          model,
+          message: `Vertex AI API error ${res.status}: ${text}`,
+          responseBody: text
+        });
+      }
       throw new ProviderError(
         `Vertex AI API error ${res.status}: ${text}`,
         this.providerName,
@@ -18327,6 +19660,9 @@ exports.HOOK_NAMES = HOOK_NAMES;
 exports.HookTimeoutError = HookTimeoutError;
 exports.InMemoryMemoryStore = InMemoryMemoryStore;
 exports.JevProvider = JevProvider;
+exports.MAX_ADJUSTMENTS = MAX_ADJUSTMENTS;
+exports.MODEL_RULES = MODEL_RULES;
+exports.ModelRequestError = ModelRequestError;
 exports.NativeJsonSchemaStrategy = NativeJsonSchemaStrategy;
 exports.OpenAICompatibleProvider = OpenAICompatibleProvider;
 exports.OpenAIProvider = OpenAIProvider;
@@ -18338,7 +19674,10 @@ exports.TOOL_INPUT_DIGEST_KEY = TOOL_INPUT_DIGEST_KEY;
 exports.ToolBasedStrategy = ToolBasedStrategy;
 exports.VertexProvider = VertexProvider;
 exports.agentVerdictRule = agentVerdictRule;
+exports.allowsSampling = allowsSampling;
 exports.appendBoundTools = appendBoundTools;
+exports.applyDropParams = applyDropParams;
+exports.asModelRequestError = asModelRequestError;
 exports.auditLog = auditLog;
 exports.azureContentSafety = azureContentSafety;
 exports.bedrockGuardrail = bedrockGuardrail;
@@ -18353,6 +19692,7 @@ exports.canOpenSkill = canOpenSkill;
 exports.canSpawn = canSpawn;
 exports.captureSnapshot = captureSnapshot;
 exports.checkpointing = checkpointing;
+exports.clearLearnedModelRules = clearLearnedModelRules;
 exports.codePresenceRule = codePresenceRule;
 exports.coerceToolArgs = coerceToolArgs;
 exports.cognipeerGuardrail = cognipeerGuardrail;
@@ -18415,6 +19755,7 @@ exports.detectTextFormat = detectTextFormat;
 exports.detectVolatileContent = detectVolatileContent;
 exports.digestToolInputArguments = digestToolInputArguments;
 exports.digestToolInputValue = digestToolInputValue;
+exports.effortBudget = effortBudget;
 exports.emptyUsage = emptyUsage;
 exports.evaluateGuardrails = evaluateGuardrails;
 exports.extractLatestUserQuery = extractLatestUserQuery;
@@ -18428,6 +19769,7 @@ exports.fromLangchainTools = fromLangchainTools;
 exports.fromNativeProvider = fromNativeProvider;
 exports.generateSpanId = generateSpanId;
 exports.generateTraceId = generateTraceId;
+exports.getLearnedModelRulePatch = getLearnedModelRulePatch;
 exports.getModelCapabilities = getModelCapabilities;
 exports.getNestedValue = getNestedValue;
 exports.getResolvedSmartConfig = getResolvedSmartConfig;
@@ -18448,12 +19790,16 @@ exports.jsonSchemaRule = jsonSchemaRule;
 exports.langfuseDefaultPayload = defaultBuildPayload;
 exports.langfuseTracing = langfuseTracing;
 exports.languageGuard = languageGuard;
+exports.listLearnedModelRules = listLearnedModelRules;
 exports.loadSkillsFromDisk = loadSkillsFromDisk;
 exports.mapConsoleHookVerdict = mapConsoleHookVerdict;
+exports.mapReasoningEffort = mapReasoningEffort;
 exports.mapTextParts = mapTextParts;
 exports.mcp = mcp;
 exports.mediaKindOf = mediaKindOf;
 exports.mediaPolicy = mediaPolicy;
+exports.mergeRulePatch = mergeRulePatch;
+exports.modelIdCandidates = modelIdCandidates;
 exports.normalizeSmartAgentOptions = normalizeSmartAgentOptions;
 exports.normalizeVerdicts = normalizeVerdicts;
 exports.openAIModeration = openAIModeration;
@@ -18461,6 +19807,7 @@ exports.otelTracing = otelTracing;
 exports.otlpSink = otlpSink;
 exports.outputGuard = outputGuard;
 exports.parseApprovalDecision = parseApprovalDecision;
+exports.parseModelError = parseModelError;
 exports.parseSkillFrontmatter = parseSkillFrontmatter;
 exports.pathSandbox = pathSandbox;
 exports.piiRedaction = piiRedaction;
@@ -18473,14 +19820,17 @@ exports.prepareStrictToolMenu = prepareStrictToolMenu;
 exports.promptInjectionGuard = promptInjectionGuard;
 exports.rateLimit = rateLimit;
 exports.readMemoryFacts = readMemoryFacts;
+exports.readTraceContinuation = readTraceContinuation;
 exports.redactText = redactText;
 exports.regexGuardrail = regexGuardrail;
 exports.regexRule = regexRule;
+exports.rememberModelRulePatch = rememberModelRulePatch;
 exports.replaceTextContent = replaceTextContent;
 exports.resolveAvailableSkills = resolveAvailableSkills;
 exports.resolveAvailableSubagents = resolveAvailableSubagents;
 exports.resolveInputRetention = resolveInputRetention;
 exports.resolveMemoryStore = resolveMemoryStore;
+exports.resolveModelRule = resolveModelRule;
 exports.resolveReasoning = resolveReasoning;
 exports.resolveStrategy = resolveStrategy;
 exports.resolveSubagentTools = resolveSubagentTools;
@@ -18491,6 +19841,7 @@ exports.responseCache = responseCache;
 exports.restoreSnapshot = restoreSnapshot;
 exports.restoreToolCalls = restoreToolCalls;
 exports.runSmartAgentEvalHarness = runSmartAgentEvalHarness;
+exports.runWithModelAdjustments = runWithModelAdjustments;
 exports.scoreItemsByRelevance = scoreItemsByRelevance;
 exports.searchSkills = searchSkills;
 exports.seedChildMessages = seedChildMessages;
@@ -18506,6 +19857,7 @@ exports.toStrictCompatible = toStrictCompatible;
 exports.toStrictToolSchema = toStrictToolSchema;
 exports.tokenize = tokenize;
 exports.toolPolicy = toolPolicy;
+exports.traceContinuationOf = traceContinuationOf;
 exports.traceSessionToOtlp = traceSessionToOtlp;
 exports.validateReasoningConfig = validateReasoningConfig;
 exports.validateToolArgs = validateToolArgs;