@cognipeer/agent-sdk 0.12.0 → 0.14.0

package/dist/index.mjs

@@ -2016,27 +2016,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;
@@ -2096,7 +2140,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";
@@ -2286,7 +2330,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;
@@ -2343,7 +2388,17 @@ async function finalizeTraceSession(session, params = {}) {
   if (sink.type === "file" && session.fileSessionDir) {
     try {
       const filePath = path.join(session.fileSessionDir, "trace.session.json");
-      await fs.promises.writeFile(filePath, JSON.stringify(finalPayload, null, 2), "utf8");
+      let filePayload = finalPayload;
+      if (finalPayload.continuation) {
+        try {
+          const previous = JSON.parse(await fs.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.promises.writeFile(filePath, JSON.stringify(filePayload, null, 2), "utf8");
     } catch (err) {
       sinkFailed = true;
       const message = err instanceof Error ? err.message : String(err);
@@ -4782,6 +4837,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) {
@@ -5095,10 +5351,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" };
       }
@@ -5250,6 +5506,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", {
@@ -5513,6 +5770,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",
@@ -5529,6 +5787,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", {
@@ -6109,7 +6368,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)) {
@@ -6625,16 +6884,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
             }
@@ -7853,15 +8116,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";
@@ -8142,7 +8407,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,
@@ -8150,6 +8415,7 @@ function createAgent(opts) {
       __onStream: onStream,
       __streaming: streamEnabled
     };
+    delete ctx.__traceContinuation;
     if (traceSession) ctx.__traceSession = traceSession;
     delete ctx.__plugins;
     delete ctx.__applySystemPromptContribution;
@@ -8298,10 +8564,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);
@@ -11205,6 +11478,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) {
@@ -11579,6 +11860,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;
   }
   /**
@@ -15246,32 +15528,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;
@@ -15285,48 +16340,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) {
@@ -15336,18 +16397,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);
@@ -15359,7 +16427,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;
@@ -15371,11 +16439,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;
@@ -15384,16 +16447,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;
 }
 
@@ -15464,6 +16528,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",
@@ -15764,8 +17033,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);
   }
@@ -15789,8 +17057,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 = "";
@@ -15894,7 +17161,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)),
@@ -15904,20 +17207,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;
@@ -15946,14 +17249,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);
   }
@@ -15966,10 +17272,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;
@@ -16058,13 +17361,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",
@@ -16096,7 +17400,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. */
@@ -16361,8 +17666,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 ?? {};
@@ -16478,12 +17783,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();
@@ -16634,7 +17933,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,
@@ -16649,6 +17948,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;
@@ -16675,9 +17975,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;
     }
@@ -16813,31 +18115,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`;
@@ -16954,6 +18253,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,
@@ -17082,6 +18382,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
@@ -17437,7 +18738,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)
@@ -17483,7 +18784,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) {
@@ -17608,16 +18914,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`;
@@ -17807,7 +19126,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);
   }
@@ -17815,7 +19134,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") ?? "";
@@ -17895,7 +19214,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 ?? []) {
@@ -18118,7 +19437,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(
@@ -18136,6 +19455,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,
@@ -18294,6 +19627,6 @@ function createProvider(config) {
   }
 }
 
-export { ASK_USER_TOOL_NAME, AnthropicProvider, AzureProvider, BaseProvider, BedrockProvider, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, GuardrailPhase, HOOK_CONTRACT_VERSION, HOOK_NAMES, HookTimeoutError, InMemoryMemoryStore, JevProvider, NativeJsonSchemaStrategy, OpenAICompatibleProvider, OpenAIProvider, PREOPEN_TOOL_CALL_PREFIX, ProviderError, SMALL_TIER_SKILL_POLICY, StructuredOutputManager, TOOL_INPUT_DIGEST_KEY, ToolBasedStrategy, VertexProvider, agentVerdictRule, appendBoundTools, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, emptyUsage, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, loadSkillsFromDisk, mapConsoleHookVerdict, mapTextParts, mcp, mediaKindOf, mediaPolicy, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseSkillFrontmatter, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, redactText, regexGuardrail, regexRule, replaceTextContent, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, supportsAdaptiveThinking, textFromContent, toMessageUsage, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceSessionToOtlp, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
+export { ASK_USER_TOOL_NAME, AnthropicProvider, AzureProvider, BaseProvider, BedrockProvider, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, GuardrailPhase, HOOK_CONTRACT_VERSION, HOOK_NAMES, HookTimeoutError, InMemoryMemoryStore, JevProvider, MAX_ADJUSTMENTS, MODEL_RULES, ModelRequestError, NativeJsonSchemaStrategy, OpenAICompatibleProvider, OpenAIProvider, PREOPEN_TOOL_CALL_PREFIX, ProviderError, SMALL_TIER_SKILL_POLICY, StructuredOutputManager, TOOL_INPUT_DIGEST_KEY, ToolBasedStrategy, VertexProvider, agentVerdictRule, allowsSampling, appendBoundTools, applyDropParams, asModelRequestError, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, clearLearnedModelRules, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, effortBudget, emptyUsage, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getLearnedModelRulePatch, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, listLearnedModelRules, loadSkillsFromDisk, mapConsoleHookVerdict, mapReasoningEffort, mapTextParts, mcp, mediaKindOf, mediaPolicy, mergeRulePatch, modelIdCandidates, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseModelError, parseSkillFrontmatter, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, readTraceContinuation, redactText, regexGuardrail, regexRule, rememberModelRulePatch, replaceTextContent, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveModelRule, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, runWithModelAdjustments, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, supportsAdaptiveThinking, textFromContent, toMessageUsage, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceContinuationOf, traceSessionToOtlp, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map