@x12i/ai-dispatcher 3.2.0 → 3.3.1

package/dist/index.js

@@ -123,7 +123,7 @@ async function openTrack(settings, model) {
   try {
     tokenCounter = await loadTokenizer(tokenizer);
     const framing = framingFor(settings);
-    const resolved = resolveSettings({
+    const resolved2 = resolveSettings({
       files: [],
       env: {},
       factory: {
@@ -138,8 +138,8 @@ async function openTrack(settings, model) {
     });
     const approvals = settings.approvals;
     const client = createCoreClient({
-      config: resolved.config,
-      explanation: resolved.explanation,
+      config: resolved2.config,
+      explanation: resolved2.explanation,
       ...approvals && approvals.length > 0 ? { policy: { approvals: [...approvals] } } : {},
       ...tokenCounter ? { tokenCounter } : {},
       warn: () => void 0
@@ -193,10 +193,10 @@ async function encodeRequestText(request, track) {
   if (typeof request.input === "string") {
     request.input = await encodeString(track, request.input);
   } else if (Array.isArray(request.input)) {
-    for (let index = 0; index < request.input.length; index += 1) {
-      const item = request.input[index];
+    for (let index2 = 0; index2 < request.input.length; index2 += 1) {
+      const item = request.input[index2];
       if (typeof item === "string") {
-        request.input[index] = await encodeString(track, item);
+        request.input[index2] = await encodeString(track, item);
       } else if (item) {
         await encodeContentRecord(item, track);
       }
@@ -393,9 +393,9 @@ function walk(current, tokens) {
   }
   if (Array.isArray(current)) {
     if (!/^\d+$/.test(head)) return [];
-    const index = Number(head);
-    if (index >= current.length) return [];
-    return walk(current[index], rest);
+    const index2 = Number(head);
+    if (index2 >= current.length) return [];
+    return walk(current[index2], rest);
   }
   if (!isRecord2(current) || !Object.prototype.hasOwnProperty.call(current, head)) return [];
   return walk(current[head], rest);
@@ -430,9 +430,9 @@ function collectParents(current, tokens) {
   }
   if (Array.isArray(current)) {
     if (!/^\d+$/.test(head)) return [];
-    const index = Number(head);
-    if (index >= current.length) return [];
-    return collectParents(current[index], rest);
+    const index2 = Number(head);
+    if (index2 >= current.length) return [];
+    return collectParents(current[index2], rest);
   }
   if (!isRecord2(current) || !Object.prototype.hasOwnProperty.call(current, head)) return [];
   return collectParents(current[head], rest);
@@ -446,8 +446,8 @@ function deletePointer(root, pointer) {
   for (const parent of parents) {
     if (Array.isArray(parent)) {
       if (!/^\d+$/.test(last)) continue;
-      const index = Number(last);
-      if (index < parent.length) parent.splice(index, 1);
+      const index2 = Number(last);
+      if (index2 < parent.length) parent.splice(index2, 1);
       continue;
     }
     if (isRecord2(parent) && Object.prototype.hasOwnProperty.call(parent, last)) {
@@ -479,6 +479,38 @@ function extractStreamReasoningText(event, response) {
   }
   return firstConcatenatedText(event, response.streamReasoningPaths);
 }
+function readReportedEffort(root) {
+  if (!isRecord3(root)) return void 0;
+  const fromRoot = effortOn(root.reasoning) ?? namedEffort(root.reasoning_effort);
+  if (fromRoot) return fromRoot;
+  if (Array.isArray(root.choices)) {
+    for (const choice of root.choices) {
+      if (!isRecord3(choice)) continue;
+      const message = isRecord3(choice.message) ? choice.message : void 0;
+      const fromMessage = message ? effortOn(message.reasoning) ?? namedEffort(message.reasoning_effort) : void 0;
+      if (fromMessage) return fromMessage;
+      const fromChoice = effortOn(choice.reasoning) ?? namedEffort(choice.reasoning_effort);
+      if (fromChoice) return fromChoice;
+    }
+  }
+  if (Array.isArray(root.output)) {
+    for (const item of root.output) {
+      if (!isRecord3(item) || item.type !== "reasoning") continue;
+      const effort = namedEffort(item.effort);
+      if (effort) return effort;
+    }
+  }
+  return void 0;
+}
+function effortOn(value) {
+  if (!isRecord3(value)) return void 0;
+  return namedEffort(value.effort);
+}
+function namedEffort(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
 function readReasoningTokens(root, paths) {
   for (const path of paths) {
     const absolute = firstNumber(root, [path]);
@@ -563,7 +595,10 @@ function splitThinkTags(text) {
 // src/apply-resolution.ts
 function applyResolution(response, prepared) {
   const result = response;
-  if (prepared.resolution) result.reasoningResolution = prepared.resolution;
+  if (prepared.resolution) {
+    const reportedEffort = readReportedEffort(response.raw?.response);
+    result.reasoningResolution = reportedEffort ? { ...prepared.resolution, reportedEffort } : prepared.resolution;
+  }
   if (prepared.cacheResolution) result.cacheResolution = prepared.cacheResolution;
   if (prepared.cacheWarnings?.length) {
     result.warnings = [...result.warnings, ...prepared.cacheWarnings];
@@ -946,9 +981,7 @@ function isRecord5(value) {
 
 // src/prepare-request.ts
 import {
-  AIProfilesError,
-  mergeReasoningBody,
-  resolveReasoning
+  mergeReasoningBody
 } from "@x12i/ai-profiles";
 
 // src/cache-apply.ts
@@ -1032,38 +1065,38 @@ function placeBedrockBreakpoint(body, ttl) {
 function markMessages(body, field, markerKey, markerValue, textType) {
   const messages = body[field];
   if (!Array.isArray(messages)) return { body, placed: false };
-  const index = stableMessageIndex(messages);
-  if (index < 0) return { body, placed: false };
-  const marked = markMessage(messages[index], markerKey, markerValue, textType);
+  const index2 = stableMessageIndex(messages);
+  if (index2 < 0) return { body, placed: false };
+  const marked = markMessage(messages[index2], markerKey, markerValue, textType);
   if (!marked) return { body, placed: false };
   const next = messages.slice();
-  next[index] = marked;
+  next[index2] = marked;
   return { placed: true, body: { ...body, [field]: next } };
 }
 function markInput(body, markerKey, markerValue, textType) {
   if (!Array.isArray(body.input)) return { body, placed: false };
-  const index = stableInputIndex(body.input);
-  if (index < 0) return { body, placed: false };
-  const marked = markMessage(body.input[index], markerKey, markerValue, textType);
+  const index2 = stableInputIndex(body.input);
+  if (index2 < 0) return { body, placed: false };
+  const marked = markMessage(body.input[index2], markerKey, markerValue, textType);
   if (!marked) return { body, placed: false };
   const next = body.input.slice();
-  next[index] = marked;
+  next[index2] = marked;
   return { placed: true, body: { ...body, input: next } };
 }
 function stableMessageIndex(messages) {
   let lastSystem = -1;
-  for (let index = 0; index < messages.length; index += 1) {
-    const message = messages[index];
-    if (isPlainRecord(message) && message.role === "system" && hasText(message.content)) lastSystem = index;
+  for (let index2 = 0; index2 < messages.length; index2 += 1) {
+    const message = messages[index2];
+    if (isPlainRecord(message) && message.role === "system" && hasText(message.content)) lastSystem = index2;
   }
   return lastSystem;
 }
 function stableInputIndex(items) {
   let lastStable = -1;
-  for (let index = 0; index < items.length; index += 1) {
-    const item = items[index];
+  for (let index2 = 0; index2 < items.length; index2 += 1) {
+    const item = items[index2];
     if (!isPlainRecord(item) || !hasText(item.content)) continue;
-    if (item.role === "system" || item.role === "developer") lastStable = index;
+    if (item.role === "system" || item.role === "developer") lastStable = index2;
   }
   return lastStable;
 }
@@ -1080,10 +1113,10 @@ function markContent(content, markerKey, markerValue, textType) {
   }
   if (!Array.isArray(content)) return void 0;
   const parts = content.map((part) => isPlainRecord(part) ? { ...part } : part);
-  for (let index = parts.length - 1; index >= 0; index -= 1) {
-    const part = parts[index];
+  for (let index2 = parts.length - 1; index2 >= 0; index2 -= 1) {
+    const part = parts[index2];
     if (!isPlainRecord(part) || typeof part.text !== "string" || !part.text.trim()) continue;
-    parts[index] = { ...part, [markerKey]: markerValue };
+    parts[index2] = { ...part, [markerKey]: markerValue };
     return parts;
   }
   return void 0;
@@ -1239,11 +1272,11 @@ function resolveCloudflarePromptCache(args) {
       warnings: []
     };
   }
-  const resolved = applyProfile({ input, mode, key, requestedTtl, resolutionBase, model, profile });
-  const ttl = resolved.plan.ttl ?? requestedTtl;
+  const resolved2 = applyProfile({ input, mode, key, requestedTtl, resolutionBase, model, profile });
+  const ttl = resolved2.plan.ttl ?? requestedTtl;
   return {
-    ...resolved,
-    plan: { ...resolved.plan, gateway: gatewayDirective(false, ttl, key) }
+    ...resolved2,
+    plan: { ...resolved2.plan, gateway: gatewayDirective(false, ttl, key) }
   };
 }
 function applyProfile(args) {
@@ -1450,22 +1483,22 @@ function restoreCloudflareModel(model, prefix) {
   return `${prefix}${model}`;
 }
 function createCloudflareProviderAdapter(options = {}, packer) {
-  const resolved = resolveCloudflareOptions(options, packer);
+  const resolved2 = resolveCloudflareOptions(options, packer);
   return {
     compile(request, call) {
-      return compileCloudflareRequest(request, resolved, call, false);
+      return compileCloudflareRequest(request, resolved2, call, false);
     },
     async run(request, call) {
       const requestId = request.id ?? "cloudflare";
       try {
-        return await runCloudflare(request, resolved, call, requestId);
+        return await runCloudflare(request, resolved2, call, requestId);
       } catch (error) {
         if (error instanceof AiDispatcherError && isConfigError(error.code)) throw error;
         return failedResponse(request, requestId, error, "chat");
       }
     },
     executeStreamingChat(request, call) {
-      return streamCloudflare(request, resolved, call);
+      return streamCloudflare(request, resolved2, call);
     }
   };
 }
@@ -2613,6 +2646,261 @@ function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/resolve-effort.ts
+import {
+  AIProfilesError,
+  resolveReasoning
+} from "@x12i/ai-profiles";
+
+// src/catalog-efforts.ts
+import { createRequire } from "module";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { loadBundledModelsCatalog } from "@x12i/ai-profiles";
+var index;
+function normalize(value) {
+  return value.trim().toLowerCase();
+}
+function addKey(keys, key, row) {
+  const normalized = normalize(key);
+  if (!normalized) return;
+  const existing = keys.get(normalized);
+  if (!existing) {
+    keys.set(normalized, row);
+    return;
+  }
+  if (existing === "ambiguous") return;
+  if (existing.modelId !== row.modelId) keys.set(normalized, "ambiguous");
+}
+function loadAssignmentAliases() {
+  const require2 = createRequire(import.meta.url);
+  const entry = require2.resolve("@x12i/ai-profiles");
+  const path = join(dirname(entry), "data", "reasoning-directives.json");
+  const document = JSON.parse(readFileSync(path, "utf8"));
+  return document.assignments ?? [];
+}
+function effortList(entry) {
+  const reasoning = entry.openrouter.reasoning;
+  const modelId = entry.openrouter.modelId;
+  if (!reasoning || !Object.prototype.hasOwnProperty.call(reasoning, "supportedEfforts")) {
+    return { kind: "unspecified", modelId };
+  }
+  if (reasoning.supportedEfforts === null) return { kind: "any", modelId };
+  if (Array.isArray(reasoning.supportedEfforts)) {
+    return { kind: "listed", modelId, efforts: reasoning.supportedEfforts };
+  }
+  return { kind: "unspecified", modelId };
+}
+function buildIndex() {
+  const catalog = loadBundledModelsCatalog();
+  const keys = /* @__PURE__ */ new Map();
+  const byCatalogId = /* @__PURE__ */ new Map();
+  for (const entry of catalog.models) {
+    const row = effortList(entry);
+    byCatalogId.set(normalize(entry.openrouter.modelId), row);
+    addKey(keys, entry.openrouter.modelId, row);
+    if (entry.openrouter.canonicalSlug) addKey(keys, entry.openrouter.canonicalSlug, row);
+    addKey(keys, `${entry.direct.provider}/${entry.direct.modelId}`, row);
+    addKey(keys, `openrouter/${entry.openrouter.modelId}`, row);
+    addKey(keys, entry.direct.modelId, row);
+  }
+  for (const assignment of loadAssignmentAliases()) {
+    const row = byCatalogId.get(normalize(assignment.catalogModelId));
+    if (!row) continue;
+    for (const alias of assignment.aliases ?? []) addKey(keys, alias, row);
+  }
+  return keys;
+}
+function lookupCatalogEfforts(model) {
+  if (!index) index = buildIndex();
+  const direct = index.get(normalize(model));
+  if (direct && direct !== "ambiguous") return direct;
+  const gateway = normalize(model);
+  if (gateway.startsWith("openrouter/")) {
+    const stripped = index.get(gateway.slice("openrouter/".length));
+    if (stripped && stripped !== "ambiguous") return stripped;
+  }
+  return void 0;
+}
+
+// src/resolve-effort.ts
+var EMPTY_RESPONSE = {
+  reasoningTextPaths: [],
+  streamReasoningKeys: [],
+  streamReasoningPaths: [],
+  stripFromHistoryPaths: [],
+  stripThinkTags: false
+};
+var MAPPER_EFFORTS = ["high", "xhigh", "max", "medium", "low", "minimal"];
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readBodyEffort(body) {
+  const reasoning = body.reasoning;
+  if (isRecord7(reasoning) && typeof reasoning.effort === "string") return reasoning.effort;
+  const fields = body.additionalModelRequestFields;
+  if (!isRecord7(fields)) return void 0;
+  const output = fields.output_config;
+  if (isRecord7(output) && typeof output.effort === "string") return output.effort;
+  return void 0;
+}
+function writeBodyEffort(body, effort) {
+  const reasoning = body.reasoning;
+  if (isRecord7(reasoning) && typeof reasoning.effort === "string") {
+    reasoning.effort = effort;
+    return true;
+  }
+  const fields = body.additionalModelRequestFields;
+  if (!isRecord7(fields)) return false;
+  const output = fields.output_config;
+  if (isRecord7(output) && typeof output.effort === "string") {
+    output.effort = effort;
+    return true;
+  }
+  return false;
+}
+function unsupported(model, effort, supported) {
+  return new AiDispatcherError(
+    "EFFORT_UNSUPPORTED",
+    `Model '${model}' does not accept reasoning effort '${effort}'. Supported efforts: ${supported.join(", ")}.`,
+    { model, effort, supportedEfforts: [...supported] }
+  );
+}
+function ignoredDirective() {
+  return {
+    outcome: "ignored",
+    body: {},
+    response: {
+      reasoningTextPaths: [...EMPTY_RESPONSE.reasoningTextPaths],
+      streamReasoningKeys: [...EMPTY_RESPONSE.streamReasoningKeys],
+      streamReasoningPaths: [...EMPTY_RESPONSE.streamReasoningPaths],
+      stripFromHistoryPaths: [...EMPTY_RESPONSE.stripFromHistoryPaths],
+      stripThinkTags: EMPTY_RESPONSE.stripThinkTags
+    }
+  };
+}
+function toDispatcherError(error) {
+  return new AiDispatcherError(error.code, error.message, error.details);
+}
+function resolveMapping(input, ignoreUnknown) {
+  try {
+    return resolveReasoning({
+      target: input.target,
+      model: input.model,
+      effort: input.effort
+    });
+  } catch (error) {
+    if (!(error instanceof AIProfilesError)) throw error;
+    if (ignoreUnknown && (error.code === "UNKNOWN_MODEL" || error.code === "REASONING_MAPPING_MISSING")) {
+      return ignoredDirective();
+    }
+    if (error.code === "INVALID_EFFORT") return "bad-key";
+    if (error.code === "REASONING_MAPPING_INVALID" && error.message.includes("missing effort")) return "bad-key";
+    throw toDispatcherError(error);
+  }
+}
+function mappingOrThrow(input, ignoreUnknown) {
+  const mapped = resolveMapping(input, ignoreUnknown);
+  if (mapped === "bad-key") {
+    throw new AiDispatcherError(
+      "INVALID_EFFORT",
+      `Invalid reasoning effort '${input.effort}'.`,
+      { target: input.target, effort: input.effort, model: input.model }
+    );
+  }
+  return mapped;
+}
+function sendAsWritten(directive, effort, target) {
+  if (directive.outcome === "ignored") return directive;
+  const copy = structuredClone(directive);
+  const wrote = writeBodyEffort(copy.body, effort);
+  if (!wrote && target !== "bedrock") {
+    const reasoning = isRecord7(copy.body.reasoning) ? copy.body.reasoning : {};
+    copy.body = { ...copy.body, reasoning: { ...reasoning, effort } };
+  }
+  copy.outcome = "applied";
+  return copy;
+}
+function directiveForListedEffort(input) {
+  const direct = resolveMapping(input, input.ignoreUnknown);
+  if (direct !== "bad-key") {
+    if (direct.outcome === "ignored") return direct;
+    const sent = readBodyEffort(direct.body);
+    if (sent === input.effort) {
+      if (direct.outcome === "degraded") {
+        const copy = structuredClone(direct);
+        copy.outcome = "applied";
+        return copy;
+      }
+      return direct;
+    }
+    if (sent) return sendAsWritten(direct, input.effort, input.target);
+  }
+  const proxies = MAPPER_EFFORTS.filter((candidate) => {
+    if (candidate === input.effort) return false;
+    if (input.supported === null) return true;
+    return input.supported.includes(candidate);
+  });
+  for (const proxy of proxies) {
+    const mapped = resolveMapping({ ...input, effort: proxy }, input.ignoreUnknown);
+    if (mapped === "bad-key" || mapped.outcome === "ignored") continue;
+    if (!readBodyEffort(mapped.body)) continue;
+    return sendAsWritten(mapped, input.effort, input.target);
+  }
+  return mappingOrThrow(input, input.ignoreUnknown);
+}
+function sentOf(directive) {
+  if (directive.outcome === "ignored") return void 0;
+  return readBodyEffort(directive.body);
+}
+function resolved(directive) {
+  const sentEffort = sentOf(directive);
+  return sentEffort ? { directive, sentEffort } : { directive };
+}
+function resolveEffortDirective(input) {
+  const effort = input.effort.trim();
+  const row = lookupCatalogEfforts(input.model);
+  if (!row) {
+    return resolved(mappingOrThrow(input, input.ignoreUnknown));
+  }
+  if (row.kind === "unspecified") {
+    const directive2 = mappingOrThrow({ ...input, effort }, input.ignoreUnknown);
+    const sent = sentOf(directive2);
+    if (!input.degrade && directive2.outcome === "degraded" && sent && sent !== effort) {
+      throw new AiDispatcherError(
+        "EFFORT_UNSUPPORTED",
+        `Model '${input.model}' does not accept reasoning effort '${effort}' unless degradeReasoningEffort is set.`,
+        { model: input.model, effort, catalogModelId: row.modelId }
+      );
+    }
+    return resolved(directive2);
+  }
+  const supported = row.kind === "listed" ? row.efforts : null;
+  const allowed = supported === null || supported.includes(effort);
+  if (!allowed && supported) {
+    if (!input.degrade) throw unsupported(input.model, effort, supported);
+    const mapped = resolveMapping({ ...input, effort }, input.ignoreUnknown);
+    if (mapped === "bad-key") throw unsupported(input.model, effort, supported);
+    if (mapped.outcome === "ignored") return { directive: mapped };
+    const sent = readBodyEffort(mapped.body);
+    if (!sent || !supported.includes(sent)) throw unsupported(input.model, effort, supported);
+    if (sent !== effort) {
+      const copy = structuredClone(mapped);
+      copy.outcome = "degraded";
+      return { directive: copy, sentEffort: sent };
+    }
+    return { directive: mapped, sentEffort: sent };
+  }
+  const directive = directiveForListedEffort({
+    target: input.target,
+    model: input.model,
+    effort,
+    ignoreUnknown: input.ignoreUnknown,
+    supported
+  });
+  return resolved(directive);
+}
+
 // src/prepare-request.ts
 function prepareDispatchRequest(params) {
   const cloned = cloneRequest(params.request);
@@ -2622,11 +2910,13 @@ function prepareDispatchRequest(params) {
   applyDispatchGate(cloned);
   const provider = params.provider;
   const reasoningEffort = cloned.reasoningEffort;
+  const degradeReasoningEffort = cloned.degradeReasoningEffort === true;
   const bedrockControls = cloned.bedrockControls;
   const cachePolicy = cloned.cache;
   const cloudflareRequest = cloned.cloudflare;
   delete cloned.provider;
   delete cloned.reasoningEffort;
+  delete cloned.degradeReasoningEffort;
   delete cloned.bedrockControls;
   delete cloned.cache;
   delete cloned.cloudflare;
@@ -2644,6 +2934,7 @@ function prepareDispatchRequest(params) {
   const requestedModel = cloned.model ?? defaultModelFor(provider, params.options) ?? "";
   const explicit = hasExplicitControl(provider, cloned, bedrockControls);
   let directive;
+  let sentEffort;
   let catalogPrefix;
   if (!explicit && reasoningEffort !== void 0) {
     if (!requestedModel) {
@@ -2655,13 +2946,29 @@ function prepareDispatchRequest(params) {
     if (provider === "cloudflare") {
       const query = cloudflareCatalogQuery(requestedModel);
       catalogPrefix = query.prefix;
-      directive = resolveCatalog({ target: query.target, model: query.model, effort: reasoningEffort }, true);
+      const resolved2 = resolveEffortDirective({
+        target: query.target,
+        model: query.model,
+        effort: reasoningEffort,
+        ignoreUnknown: true,
+        degrade: degradeReasoningEffort
+      });
+      directive = resolved2.directive;
+      sentEffort = resolved2.sentEffort;
     } else if (isReasoningTarget(provider)) {
-      directive = resolveCatalog({ target: provider, model: requestedModel, effort: reasoningEffort }, false);
+      const resolved2 = resolveEffortDirective({
+        target: provider,
+        model: requestedModel,
+        effort: reasoningEffort,
+        ignoreUnknown: false,
+        degrade: degradeReasoningEffort
+      });
+      directive = resolved2.directive;
+      sentEffort = resolved2.sentEffort;
     }
   }
   if (provider === "openrouter") {
-    applyNestedReasoning(cloned, reasoningEffort);
+    applyNestedReasoning(cloned, reasoningEffort, degradeReasoningEffort);
   }
   if (directive?.model) {
     cloned.model = provider === "cloudflare" ? restoreCloudflareModel(directive.model, catalogPrefix) : directive.model;
@@ -2722,6 +3029,7 @@ function prepareDispatchRequest(params) {
   }
   const resolution = reasoningEffort !== void 0 || explicit ? buildResolution({
     requestedEffort: reasoningEffort,
+    sentEffort: explicit ? explicitSentEffort(provider, cloned, bedrockControls) : sentEffort,
     target: provider,
     requestedModel,
     effectiveModel,
@@ -2754,29 +3062,6 @@ function noteUnplacedCache(resolution, warnings, target, model) {
     details: { target, model }
   });
 }
-function resolveCatalog(input, ignoreUnknown) {
-  try {
-    return resolveReasoning(input);
-  } catch (error) {
-    if (error instanceof AIProfilesError) {
-      if (ignoreUnknown && (error.code === "UNKNOWN_MODEL" || error.code === "REASONING_MAPPING_MISSING")) {
-        return {
-          outcome: "ignored",
-          body: {},
-          response: {
-            reasoningTextPaths: [],
-            streamReasoningKeys: [],
-            streamReasoningPaths: [],
-            stripFromHistoryPaths: [],
-            stripThinkTags: false
-          }
-        };
-      }
-      throw new AiDispatcherError(error.code, error.message, error.details);
-    }
-    throw error;
-  }
-}
 function isReasoningTarget(provider) {
   return provider === "openrouter" || provider === "bedrock" || provider === "openai";
 }
@@ -2784,6 +3069,15 @@ function hasExplicitControl(provider, request, bedrockControls) {
   if (provider === "bedrock") return bedrockControls?.additionalModelRequestFields !== void 0;
   return request.reasoning !== void 0;
 }
+function explicitSentEffort(provider, request, bedrockControls) {
+  if (provider === "bedrock") {
+    const output = bedrockControls?.additionalModelRequestFields?.output_config;
+    if (isRecord8(output) && typeof output.effort === "string") return output.effort;
+    return void 0;
+  }
+  if (isRecord8(request.reasoning) && typeof request.reasoning.effort === "string") return request.reasoning.effort;
+  return void 0;
+}
 function buildResolution(params) {
   return {
     target: params.target,
@@ -2791,19 +3085,20 @@ function buildResolution(params) {
     effectiveModel: params.effectiveModel,
     bypassed: params.bypassed,
     ...params.requestedEffort ? { requestedEffort: params.requestedEffort } : {},
+    ...params.sentEffort ? { sentEffort: params.sentEffort } : {},
     ...params.outcome ? { outcome: params.outcome } : {}
   };
 }
-function applyNestedReasoning(request, parentEffort) {
+function applyNestedReasoning(request, parentEffort, degrade) {
   const serverTools = request.serverTools;
   if (!serverTools) return;
-  if (serverTools.fusion) serverTools.fusion = settleNested(serverTools.fusion, "fusion", parentEffort);
+  if (serverTools.fusion) serverTools.fusion = settleNested(serverTools.fusion, "fusion", parentEffort, degrade);
   if (serverTools.advisor) {
-    serverTools.advisor = Array.isArray(serverTools.advisor) ? serverTools.advisor.map((advisor) => settleNested(advisor, "advisor", parentEffort)) : settleNested(serverTools.advisor, "advisor", parentEffort);
+    serverTools.advisor = Array.isArray(serverTools.advisor) ? serverTools.advisor.map((advisor) => settleNested(advisor, "advisor", parentEffort, degrade)) : settleNested(serverTools.advisor, "advisor", parentEffort, degrade);
   }
-  if (serverTools.subagent) serverTools.subagent = settleNested(serverTools.subagent, "subagent", parentEffort);
+  if (serverTools.subagent) serverTools.subagent = settleNested(serverTools.subagent, "subagent", parentEffort, degrade);
 }
-function settleNested(policy, kind, parentEffort) {
+function settleNested(policy, kind, parentEffort, degrade) {
   const current = policy;
   const childEffort = current.reasoningEffort;
   const next = { ...current };
@@ -2813,12 +3108,18 @@ function settleNested(policy, kind, parentEffort) {
   if (!effort) return next;
   const model = kind === "fusion" ? next.judgeModel : next.model;
   if (!model) return next;
-  const directive = resolveCatalog({ target: "openrouter", model, effort }, false);
+  const directive = resolveEffortDirective({
+    target: "openrouter",
+    model,
+    effort,
+    ignoreUnknown: false,
+    degrade
+  }).directive;
   if (directive.model) {
     if (kind === "fusion") next.judgeModel = directive.model;
     else next.model = directive.model;
   }
-  if (isRecord7(directive.body.reasoning)) next.reasoning = directive.body.reasoning;
+  if (isRecord8(directive.body.reasoning)) next.reasoning = directive.body.reasoning;
   return next;
 }
 function applyPromptPrefix(request, prefix) {
@@ -2855,10 +3156,10 @@ function prefixMessages(messages, prefix) {
   return false;
 }
 function prefixInputItems(items, prefix) {
-  for (let index = 0; index < items.length; index += 1) {
-    const item = items[index];
+  for (let index2 = 0; index2 < items.length; index2 += 1) {
+    const item = items[index2];
     if (typeof item === "string") {
-      items[index] = prefix + item;
+      items[index2] = prefix + item;
       return true;
     }
     if (!item || item.role === "system") continue;
@@ -2868,7 +3169,7 @@ function prefixInputItems(items, prefix) {
     }
     if (!Array.isArray(item.content)) continue;
     for (const part of item.content) {
-      if (!isRecord7(part) || typeof part.text !== "string") continue;
+      if (!isRecord8(part) || typeof part.text !== "string") continue;
       if (part.type === "text" || part.type === "input_text") {
         part.text = prefix + part.text;
         return true;
@@ -2929,7 +3230,7 @@ var ROLE_STAMP_FIELDS = ["role", "roleLayer", "roleDigest", "profileChoice"];
 function applyRoleStamp(request) {
   const stamp = request.role;
   delete request.role;
-  if (!isRecord7(stamp)) return;
+  if (!isRecord8(stamp)) return;
   const identity = {};
   for (const field of ROLE_STAMP_FIELDS) {
     const value = stamp[field];
@@ -2944,8 +3245,8 @@ function applyRoleStamp(request) {
 }
 function absorbOverrideMetadata(request) {
   const overrides = request.rawOpenRouterOverrides;
-  if (!isRecord7(overrides) || !Object.prototype.hasOwnProperty.call(overrides, "metadata")) return;
-  if (isRecord7(overrides.metadata)) {
+  if (!isRecord8(overrides) || !Object.prototype.hasOwnProperty.call(overrides, "metadata")) return;
+  if (isRecord8(overrides.metadata)) {
     const current = { ...request.metadata ?? {} };
     const extra = {};
     for (const [key, value] of Object.entries(overrides.metadata)) {
@@ -2990,7 +3291,7 @@ function hasOwnKeys(value) {
 function hasStreamMetadata(directive) {
   return directive.response.streamReasoningKeys.length > 0 || directive.response.streamReasoningPaths.length > 0;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readEnv2(name) {
@@ -3141,22 +3442,22 @@ import {
 var DEFAULT_BASE_URL2 = "https://api.openai.com/v1";
 var DEFAULT_TIMEOUT_MS2 = 12e4;
 function createOpenAiProviderAdapter(options = {}, packer) {
-  const resolved = resolveOpenAiOptions(options, packer);
+  const resolved2 = resolveOpenAiOptions(options, packer);
   return {
     compile(request, call) {
-      return compileOpenAiRequest(request, resolved, call, false);
+      return compileOpenAiRequest(request, resolved2, call, false);
     },
     async run(request, call) {
       const requestId = request.id ?? "openai";
       try {
-        return await runOpenAi(request, resolved, call, requestId);
+        return await runOpenAi(request, resolved2, call, requestId);
       } catch (error) {
         if (error instanceof AiDispatcherError && isConfigError2(error.code)) throw error;
         return failedResponse2(request, requestId, error);
       }
     },
     executeStreamingChat(request, call) {
-      return streamOpenAi(request, resolved, call);
+      return streamOpenAi(request, resolved2, call);
     }
   };
 }
@@ -3313,7 +3614,7 @@ async function runOpenAi(request, options, call, requestId) {
   let response;
   for (let iteration = 0; iteration <= maxIterations; iteration += 1) {
     response = await sendWithRetries2(active, options, timeoutFor2(request, options));
-    const calls = functionCalls(isRecord8(response) ? response : {});
+    const calls = functionCalls(isRecord9(response) ? response : {});
     if (!calls.length) break;
     if (!calls.every((item) => resolveExecutor2(item.name, request, options))) {
       return normalizeOpenAiResponse({
@@ -3333,7 +3634,7 @@ async function runOpenAi(request, options, call, requestId) {
       results.push(await executeOpenAiTool(item, request, options));
     }
     functionUsage.push(...results);
-    const record2 = isRecord8(response) ? response : {};
+    const record2 = isRecord9(response) ? response : {};
     active = {
       ...active,
       body: clean2({
@@ -3448,7 +3749,7 @@ async function* streamOpenAi(request, options, call) {
       throw failure;
     }
     for await (const event of parseSse2(response)) {
-      if (!isRecord8(event)) continue;
+      if (!isRecord9(event)) continue;
       if (event.type === "response.output_text.delta" && typeof event.delta === "string" && event.delta) {
         text += event.delta;
         yield { type: "stream.text.delta", requestId, data: { text: event.delta } };
@@ -3467,7 +3768,7 @@ async function* streamOpenAi(request, options, call) {
             argumentsDelta: event.delta
           }
         };
-      } else if (event.type === "response.completed" && isRecord8(event.response)) {
+      } else if (event.type === "response.completed" && isRecord9(event.response)) {
         const usage = normalizeUsage2(event.response.usage);
         if (usage) yield { type: "stream.usage", requestId, data: { usage } };
       } else if (event.type === "error") {
@@ -3561,7 +3862,7 @@ function isConfigError2(code) {
 }
 function asTerminalError2(error) {
   if (error instanceof AiDispatcherError && error.code === "PROVIDER_RETRYABLE") {
-    const status = isRecord8(error.details) ? error.details.status : void 0;
+    const status = isRecord9(error.details) ? error.details.status : void 0;
     if (status === 429) return new AiDispatcherError("PROVIDER_RATE_LIMITED", error.message, error.details);
     return new AiDispatcherError("PROVIDER_GATEWAY_UNREACHABLE", error.message, error.details);
   }
@@ -3569,7 +3870,7 @@ function asTerminalError2(error) {
   return new AiDispatcherError("PROVIDER_REQUEST_FAILED", error instanceof Error ? error.message : String(error));
 }
 function normalizeOpenAiResponse(params) {
-  const record2 = isRecord8(params.response) ? params.response : {};
+  const record2 = isRecord9(params.response) ? params.response : {};
   const text = answerText2(record2);
   const calls = params.functionTools ?? functionCalls(record2);
   const usage = normalizeUsage2(record2.usage);
@@ -3596,9 +3897,9 @@ function answerText2(response) {
   if (Array.isArray(output)) {
     const parts = [];
     for (const item of output) {
-      if (!isRecord8(item) || item.type === "reasoning" || item.type !== "message" || !Array.isArray(item.content)) continue;
+      if (!isRecord9(item) || item.type === "reasoning" || item.type !== "message" || !Array.isArray(item.content)) continue;
       for (const part of item.content) {
-        if (isRecord8(part) && part.type === "output_text" && typeof part.text === "string") parts.push(part.text);
+        if (isRecord9(part) && part.type === "output_text" && typeof part.text === "string") parts.push(part.text);
       }
     }
     if (parts.length > 0) return parts.join("");
@@ -3609,7 +3910,7 @@ function functionCalls(response) {
   if (!Array.isArray(response.output)) return [];
   const calls = [];
   for (const item of response.output) {
-    if (!isRecord8(item) || item.type !== "function_call") continue;
+    if (!isRecord9(item) || item.type !== "function_call") continue;
     const name = typeof item.name === "string" ? item.name : "function";
     const callId = typeof item.call_id === "string" ? item.call_id : name;
     let args = item.arguments;
@@ -3641,7 +3942,7 @@ function toolUsage(calls) {
   };
 }
 function normalizeUsage2(usage) {
-  if (!isRecord8(usage)) return void 0;
+  if (!isRecord9(usage)) return void 0;
   const inputTokens = numberValue2(usage.input_tokens);
   const outputTokens = numberValue2(usage.output_tokens);
   const totalTokens = numberValue2(usage.total_tokens) ?? (inputTokens !== void 0 || outputTokens !== void 0 ? (inputTokens ?? 0) + (outputTokens ?? 0) : void 0);
@@ -3693,16 +3994,16 @@ function modelOf2(compiled) {
   return typeof compiled.body.model === "string" ? compiled.body.model : "";
 }
 function messageFrom2(body) {
-  if (!isRecord8(body)) return void 0;
+  if (!isRecord9(body)) return void 0;
   if (typeof body.message === "string") return body.message;
-  if (isRecord8(body.error) && typeof body.error.message === "string") return body.error.message;
+  if (isRecord9(body.error) && typeof body.error.message === "string") return body.error.message;
   return void 0;
 }
 function numberValue2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function attachProviderMetadata(body, request, packer) {
-  const fromBody = isRecord8(body.metadata) ? body.metadata : void 0;
+  const fromBody = isRecord9(body.metadata) ? body.metadata : void 0;
   const packed = packProviderRecord2(request.metadata, request.agentId, fromBody, packer);
   if (packed.wire) return { body: { ...body, metadata: packed.wire }, ...packed.warning ? { warning: packed.warning } : {} };
   if (body.metadata === void 0) return { body, ...packed.warning ? { warning: packed.warning } : {} };
@@ -3776,7 +4077,7 @@ function readEnv3(name) {
   if (typeof process === "undefined") return void 0;
   return process.env[name];
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -3960,7 +4261,7 @@ function callOf(call) {
 }
 function attachCompileMeta(prepared, compiled) {
   const record2 = compiled;
-  const headers = isRecord9(record2.headers) ? redactHeaders(record2.headers) : void 0;
+  const headers = isRecord10(record2.headers) ? redactHeaders(record2.headers) : void 0;
   const inputResolution = prepared.inputTrack ? visibleInputResolution(prepared.inputTrack) : void 0;
   return {
     ...record2,
@@ -3996,7 +4297,7 @@ function log(options, event, prepared, entrypoint, streaming) {
   if (event.endsWith("compiled")) options.logger?.debug?.(event, payload);
   else options.logger?.info?.(event, payload);
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }