@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-U45AXT5D.js

@@ -0,0 +1,1023 @@
+import {
+  deactivateProxyOnConnectionFailure,
+  waitForProxyRoutingSettle
+} from "./chunk-4SJNS7OB.js";
+import {
+  scrubErrorText
+} from "./chunk-Y5YXDM7D.js";
+import {
+  runWithNetworkTelemetry
+} from "./chunk-HA4ZYA6T.js";
+import {
+  FallbackProfileManager,
+  evaluateModelCalendar,
+  logicalCalendarTarget
+} from "./chunk-WQQON3SV.js";
+import {
+  createChroniclePromptManifest
+} from "./chunk-2YU4WVBW.js";
+import {
+  bindRequestProvider,
+  completePartialObject,
+  resolveEventSessionId
+} from "./chunk-ZHZ2Y2DH.js";
+import {
+  ProviderError,
+  isFallbackWorthy
+} from "./chunk-3ECENVHL.js";
+import {
+  isTextBlock,
+  isToolUseBlock
+} from "./chunk-O37BQ65S.js";
+import {
+  toWrongStackError
+} from "./chunk-25LSLC3G.js";
+
+// src/core/streaming-response-builder.ts
+import { randomUUID } from "node:crypto";
+var STREAM_DRAIN_TIMEOUT_MS = 500;
+function buildResponse(state) {
+  const content = [];
+  for (const b of state.blockOrder) {
+    if (b.kind === "text") {
+      const txt = state.textBuffers[b.idx] ?? "";
+      if (txt) content.push({ type: "text", text: txt });
+    } else if (b.kind === "thinking") {
+      const t = state.thinking[b.idx];
+      if (!t) continue;
+      if (!t.textBuf && !t.signature) continue;
+      const block = { type: "thinking", thinking: t.textBuf };
+      if (t.signature) block.signature = t.signature;
+      if (t.providerMeta && Object.keys(t.providerMeta).length > 0) {
+        block.providerMeta = t.providerMeta;
+      }
+      content.push(block);
+    } else {
+      const tb = state.tools.get(b.id);
+      if (tb) {
+        const block = {
+          type: "tool_use",
+          id: b.id,
+          name: tb.name,
+          input: tb.input ?? {}
+        };
+        if (tb.providerMeta && Object.keys(tb.providerMeta).length > 0) {
+          block.providerMeta = tb.providerMeta;
+        }
+        content.push(block);
+      }
+    }
+  }
+  if (content.length === 0) content.push({ type: "text", text: "" });
+  return { content, stopReason: state.stopReason, usage: state.usage, model: state.model };
+}
+function createStreamingState(model) {
+  return {
+    model,
+    stopReason: "end_turn",
+    usage: { input: 0, output: 0 },
+    textBuffers: [],
+    currentTextIndex: -1,
+    tools: /* @__PURE__ */ new Map(),
+    thinking: [],
+    currentThinkingIndex: -1,
+    blockOrder: []
+  };
+}
+function handleMessageStart(state, model) {
+  state.model = model;
+}
+function handleContentBlockStart(state, ev) {
+  const kind = ev.kind ?? "text";
+  if (kind === "text") {
+    state.currentTextIndex = state.textBuffers.length;
+    state.textBuffers.push("");
+    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
+  } else if (kind === "tool_use") {
+    const id = ev.id ?? randomUUID();
+    state.tools.set(id, { name: ev.name ?? "unknown", partial: "" });
+    state.blockOrder.push({ kind: "tool", id });
+    state.currentTextIndex = -1;
+  } else if (kind === "thinking") {
+    state.currentThinkingIndex = state.thinking.length;
+    state.thinking.push({
+      textBuf: "",
+      ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
+    });
+    state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
+    state.currentTextIndex = -1;
+  }
+}
+function handleContentBlockStop(state, ev) {
+  void state;
+  void ev;
+}
+function handleTextDelta(state, text) {
+  if (state.currentTextIndex === -1) {
+    state.currentTextIndex = state.textBuffers.length;
+    state.textBuffers.push("");
+    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
+  }
+  state.textBuffers[state.currentTextIndex] = (state.textBuffers[state.currentTextIndex] ?? "") + text;
+}
+function handleToolUseStart(state, ev) {
+  state.currentTextIndex = -1;
+  state.tools.set(ev.id, { name: ev.name, partial: "" });
+  state.blockOrder.push({ kind: "tool", id: ev.id });
+}
+function handleToolUseInputDelta(state, ev) {
+  const t = state.tools.get(ev.id);
+  if (t) t.partial += ev.partial;
+}
+function safeJsonOrRaw(s) {
+  if (!s) return {};
+  try {
+    return JSON.parse(s);
+  } catch {
+    const repaired = completePartialObject(s);
+    try {
+      return JSON.parse(repaired);
+    } catch {
+      return { _raw: repaired };
+    }
+  }
+}
+function handleToolUseStop(state, ev) {
+  const t = state.tools.get(ev.id);
+  if (t) {
+    t.input = ev.input !== void 0 ? ev.input : safeJsonOrRaw(t.partial);
+    if (ev.providerMeta) t.providerMeta = ev.providerMeta;
+  }
+  state.currentTextIndex = -1;
+}
+function handleThinkingStart(state, ev) {
+  state.currentThinkingIndex = state.thinking.length;
+  state.thinking.push({
+    textBuf: "",
+    ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
+  });
+  state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
+  state.currentTextIndex = -1;
+}
+function handleThinkingDelta(state, text) {
+  if (state.currentThinkingIndex === -1) {
+    handleThinkingStart(state, {});
+  }
+  const t = state.thinking[state.currentThinkingIndex];
+  if (t) t.textBuf += text;
+}
+function handleThinkingSignature(state, signature) {
+  if (state.currentThinkingIndex === -1) {
+    handleThinkingStart(state, {});
+  }
+  const t = state.thinking[state.currentThinkingIndex];
+  if (t) t.signature = signature;
+}
+function handleThinkingStop(state) {
+  state.currentThinkingIndex = -1;
+}
+function handleMessageStop(state, ev) {
+  state.stopReason = ev.stopReason ?? "end_turn";
+  state.usage = ev.usage ?? { input: 0, output: 0 };
+}
+async function streamProviderToResponse(provider, req, signal, ctx, events, logger) {
+  const state = createStreamingState(req.model);
+  const sessionId = resolveEventSessionId(ctx);
+  logger.debug("Stream started", { providerId: provider.id, model: req.model });
+  const TEXT_BATCH_SIZE = 4;
+  let pendingText = "";
+  let pendingCount = 0;
+  const flushText = () => {
+    if (pendingCount > 0) {
+      events.emit("provider.text_delta", { sessionId, ctx, text: pendingText });
+      pendingText = "";
+      pendingCount = 0;
+    }
+  };
+  const iter = provider.stream(req, { signal })[Symbol.asyncIterator]();
+  try {
+    for (; ; ) {
+      const next = await iter.next();
+      if (next.done) break;
+      const ev = next.value;
+      try {
+        switch (ev.type) {
+          case "message_start":
+            handleMessageStart(state, ev.model);
+            break;
+          case "content_block_start":
+            handleContentBlockStart(state, ev);
+            break;
+          case "content_block_stop":
+            handleContentBlockStop(state, ev);
+            break;
+          case "text_delta":
+            handleTextDelta(state, ev.text);
+            pendingText += ev.text;
+            pendingCount++;
+            if (pendingCount >= TEXT_BATCH_SIZE) flushText();
+            break;
+          case "tool_use_start": {
+            flushText();
+            const idVal = ev.id;
+            const nameVal = ev.name;
+            handleToolUseStart(state, { id: idVal, name: nameVal });
+            const emittedPayload = {
+              sessionId,
+              ctx,
+              id: idVal ?? "unknown",
+              name: nameVal ?? "unknown"
+            };
+            events.emit("provider.tool_use_start", emittedPayload);
+            break;
+          }
+          case "tool_use_input_delta":
+            handleToolUseInputDelta(state, ev);
+            break;
+          case "tool_use_stop": {
+            flushText();
+            const stoppedName = state.tools.get(ev.id)?.name ?? "unknown";
+            handleToolUseStop(state, ev);
+            events.emit("provider.tool_use_stop", { sessionId, ctx, id: ev.id, name: stoppedName });
+            break;
+          }
+          case "thinking_start":
+            handleThinkingStart(state, ev);
+            break;
+          case "thinking_delta":
+            flushText();
+            handleThinkingDelta(state, ev.text);
+            events.emit("provider.thinking_delta", { sessionId, ctx, text: ev.text });
+            break;
+          case "thinking_signature":
+            handleThinkingSignature(state, ev.signature);
+            break;
+          case "thinking_stop":
+            handleThinkingStop(state);
+            break;
+          case "message_stop":
+            handleMessageStop(state, ev);
+            break;
+          default: {
+            const unknownEv = ev;
+            logger.warn(`Stream received unknown event type: "${String(unknownEv.type)}"`, {
+              providerId: provider.id,
+              model: req.model,
+              eventType: String(unknownEv.type)
+            });
+            break;
+          }
+        }
+      } catch (handlerErr) {
+        const errMsg = handlerErr instanceof Error ? handlerErr.message : String(handlerErr);
+        const evAny = ev;
+        logger.warn(`Stream handler error for event type "${String(evAny.type)}": ${errMsg}`, {
+          providerId: provider.id,
+          model: req.model,
+          eventType: String(evAny.type),
+          errorMessage: errMsg
+        });
+        flushText();
+        events.emit("provider.stream_error", {
+          sessionId,
+          ctx,
+          eventType: String(evAny.type),
+          msg: errMsg
+        });
+      }
+    }
+  } catch (err) {
+    if (signal.aborted) {
+      state.stopReason = "end_turn";
+      flushText();
+      logger.debug("Stream aborted \u2014 returning partial state", {
+        providerId: provider.id,
+        model: req.model,
+        textBlockCount: state.textBuffers.length,
+        toolBlockCount: state.tools.size,
+        thinkingBlockCount: state.thinking.length
+      });
+      return buildResponse(state);
+    }
+    throw err;
+  } finally {
+    try {
+      let drainTimer = null;
+      try {
+        const drainPromise = Promise.resolve(iter.return?.()).catch(() => {
+        });
+        await Promise.race([
+          drainPromise,
+          new Promise((resolve) => {
+            drainTimer = setTimeout(resolve, STREAM_DRAIN_TIMEOUT_MS);
+          })
+        ]);
+      } finally {
+        if (drainTimer) clearTimeout(drainTimer);
+      }
+    } catch {
+    }
+  }
+  flushText();
+  logger.debug("Stream completed", {
+    providerId: provider.id,
+    model: req.model,
+    stopReason: state.stopReason,
+    textBlockCount: state.textBuffers.length,
+    toolBlockCount: state.tools.size,
+    thinkingBlockCount: state.thinking.length,
+    usageInput: state.usage.input,
+    usageOutput: state.usage.output
+  });
+  return buildResponse(state);
+}
+
+// src/core/provider-runner.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+function scrubProviderBody(body) {
+  if (!body) return void 0;
+  return {
+    ...body,
+    ...body.type !== void 0 ? { type: scrubErrorText(body.type) } : {},
+    ...body.message !== void 0 ? { message: scrubErrorText(body.message) } : {},
+    ...body.raw !== void 0 ? { raw: scrubErrorText(body.raw) } : {},
+    ...body.requestId !== void 0 ? { requestId: scrubErrorText(body.requestId) } : {}
+  };
+}
+function providerLogCtx(p, r) {
+  return {
+    providerId: p.id,
+    model: r.model,
+    streaming: p.capabilities.streaming,
+    msgCount: r.messages.length,
+    toolCount: r.tools?.length ?? 0
+  };
+}
+var PROVIDER_FAILURE_TRACKED = /* @__PURE__ */ Symbol.for("wrongstack.providerFailureTracked");
+function isProviderFailureTracked(err) {
+  return !!err && typeof err === "object" && err[PROVIDER_FAILURE_TRACKED] === true;
+}
+function markProviderFailureTracked(err) {
+  if (!err || typeof err !== "object") return;
+  try {
+    Object.defineProperty(err, PROVIDER_FAILURE_TRACKED, {
+      value: true,
+      enumerable: false,
+      configurable: true,
+      writable: true
+    });
+  } catch {
+  }
+}
+async function runProviderWithRetry(opts) {
+  const { provider, request, signal, ctx, events, retry, logger, tracer, statusTracker } = opts;
+  const logicalRequestId = randomUUID2();
+  const promptManifest = createChroniclePromptManifest(request);
+  ctx.activeLogicalRequestId = logicalRequestId;
+  ctx.activePromptManifestId = promptManifest.manifestId;
+  let attempt = 0;
+  for (; ; ) {
+    const currentProvider = ctx.provider && ctx.provider.id === provider.id ? ctx.provider : provider;
+    if (statusTracker && !statusTracker.isAvailable(currentProvider.id, request.model)) {
+      const status = statusTracker.getStatus(currentProvider.id, request.model);
+      const until = status?.stateExpiresAt;
+      const detail = status?.lastErrorMessage ?? "rate limit or repeated failures";
+      logger.warn(
+        `provider-gate: refusing "${currentProvider.id}/${request.model}" \u2014 quarantined${until ? ` for another ${Math.max(0, Math.round((until - Date.now()) / 1e3))}s` : ""} (${detail})`,
+        providerLogCtx(currentProvider, request)
+      );
+      const gateErr = new ProviderError(
+        `"${currentProvider.id}/${request.model}" is in the provider waiting room \u2014 skipped without calling the API (${detail})`,
+        429,
+        true,
+        currentProvider.id,
+        {
+          kind: "rate_limit",
+          body: {
+            type: "rate_limit_error",
+            message: detail,
+            ...until ? { retryAfterMs: Math.max(0, until - Date.now()) } : {}
+          }
+        }
+      );
+      markProviderFailureTracked(gateErr);
+      throw gateErr;
+    }
+    const attemptId = randomUUID2();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startedNs = process.hrtime.bigint();
+    const correlation = {
+      sessionId: resolveEventSessionId(ctx),
+      ...ctx.traceId ? { traceId: ctx.traceId } : {},
+      ...ctx.agentId ? { agentId: ctx.agentId } : {},
+      logicalRequestId,
+      promptManifestId: promptManifest.manifestId,
+      attemptId,
+      attempt,
+      providerId: currentProvider.id,
+      model: request.model,
+      taskId: ctx.currentKanbanTaskId,
+      boardId: ctx.currentKanbanBoardId
+    };
+    events.emit("provider.attempt.started", {
+      ...correlation,
+      streaming: currentProvider.capabilities.streaming,
+      messageCount: request.messages.length,
+      toolCount: request.tools?.length ?? 0,
+      promptManifest,
+      startedAt
+    });
+    const span = tracer?.startSpan("provider.complete", {
+      "provider.id": currentProvider.id,
+      "provider.model": request.model,
+      "provider.streaming": currentProvider.capabilities.streaming,
+      "provider.attempt": attempt
+    });
+    logger.debug(
+      `Provider attempt ${attempt + 1} starting`,
+      providerLogCtx(currentProvider, request)
+    );
+    try {
+      const res = await runWithNetworkTelemetry(
+        {
+          events,
+          sessionId: resolveEventSessionId(ctx),
+          ...ctx.traceId ? { traceId: ctx.traceId } : {},
+          ...ctx.agentId ? { agentId: ctx.agentId } : {},
+          attemptId,
+          initiator: "provider",
+          operationName: `${currentProvider.id}.complete`
+        },
+        () => currentProvider.capabilities.streaming ? streamProviderToResponse(currentProvider, request, signal, ctx, events, logger) : currentProvider.complete(request, { signal })
+      );
+      statusTracker?.recordSuccess(currentProvider.id, request.model, {
+        sessionId: resolveEventSessionId(ctx),
+        ...ctx.agentId ? { agentId: ctx.agentId } : {}
+      });
+      span?.setAttribute("provider.stopReason", res.stopReason);
+      span?.setAttribute("provider.usage_in", res.usage.input);
+      span?.setAttribute("provider.usage_out", res.usage.output);
+      span?.end();
+      events.emit("provider.attempt.completed", {
+        ...correlation,
+        startedAt,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: elapsedMs(startedNs),
+        stopReason: res.stopReason,
+        usage: res.usage
+      });
+      logger.debug("Provider call succeeded", {
+        ...providerLogCtx(currentProvider, request),
+        stopReason: res.stopReason,
+        usageInput: res.usage.input,
+        usageOutput: res.usage.output,
+        cacheRead: res.usage.cacheRead,
+        cacheWrite: res.usage.cacheWrite,
+        attempts: attempt + 1
+      });
+      return res;
+    } catch (err) {
+      if (err instanceof Error) span?.recordError(err);
+      span?.end();
+      if (signal.aborted) throw err;
+      if (deactivateProxyOnConnectionFailure(err)) {
+        await waitForProxyRoutingSettle(void 0, signal);
+        if (signal.aborted) throw err;
+        logger.info(
+          "WrongProxy connection failed \u2014 deactivated proxy and switched to direct provider connection"
+        );
+      }
+      const isProviderErr = err instanceof ProviderError || ProviderError.isProviderError(err);
+      const errAsErr = err instanceof Error ? err : new Error(String(err));
+      const canRetry = retry.shouldRetry(isProviderErr ? err : errAsErr, attempt);
+      const providerErrorBody = isProviderErr ? scrubProviderBody(err.body) : void 0;
+      const description = scrubErrorText(
+        isProviderErr ? err.describe() : errAsErr.message
+      );
+      const delay = canRetry ? Math.round(retry.delayMs(attempt, isProviderErr ? err : errAsErr)) : void 0;
+      events.emit("provider.attempt.failed", {
+        ...correlation,
+        startedAt,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: elapsedMs(startedNs),
+        status: isProviderErr ? err.status : 0,
+        failureKind: isProviderErr ? err.kind : "unknown",
+        description,
+        retryable: canRetry,
+        retryScheduled: canRetry,
+        ...delay !== void 0 ? { retryDelayMs: delay } : {},
+        ...providerErrorBody?.requestId ? { providerRequestId: providerErrorBody.requestId } : {},
+        ...providerErrorBody ? { errorBody: providerErrorBody } : {}
+      });
+      if (!canRetry) {
+        if (statusTracker && isProviderErr && !isProviderFailureTracked(err)) {
+          const perr = err;
+          markProviderFailureTracked(err);
+          statusTracker.recordFailure(
+            currentProvider.id,
+            request.model,
+            perr.kind,
+            perr.status,
+            description,
+            {
+              sessionId: resolveEventSessionId(ctx),
+              ...ctx.agentId ? { agentId: ctx.agentId } : {},
+              ...perr.body?.retryAfterMs ? { retryAfterMs: perr.body.retryAfterMs } : {}
+            }
+          );
+        }
+        events.emit("provider.error", {
+          sessionId: resolveEventSessionId(ctx),
+          providerId: isProviderErr ? err.providerId : provider.id,
+          status: isProviderErr ? err.status : 0,
+          description,
+          retryable: false,
+          ...providerErrorBody ? { errorBody: providerErrorBody } : {}
+        });
+        logger.error(`Provider call failed after ${attempt + 1} attempt(s) \u2014 ${description}`, {
+          ...providerLogCtx(provider, request),
+          attempts: attempt + 1,
+          errorDescription: description,
+          status: isProviderErr ? err.status : void 0,
+          errorBody: providerErrorBody,
+          errorName: err instanceof Error ? err.name : void 0,
+          errorStack: err instanceof Error ? err.stack?.split("\n").slice(0, 3).join("\n") : void 0
+        });
+        throw isProviderErr ? err : toWrongStackError(err);
+      }
+      const attemptNum = attempt + 1;
+      const maxAttempts = retry.maxAttempts(isProviderErr ? err : errAsErr);
+      logger.warn(`Provider retry ${attemptNum}/${maxAttempts} in ${delay}ms \u2014 ${description}`, {
+        ...providerLogCtx(provider, request),
+        attempt: attemptNum,
+        maxAttempts,
+        delayMs: delay,
+        errorDescription: description,
+        status: isProviderErr ? err.status : void 0,
+        errorBody: providerErrorBody
+      });
+      events.emit("provider.retry", {
+        sessionId: resolveEventSessionId(ctx),
+        providerId: isProviderErr ? err.providerId : provider.id,
+        attempt: attemptNum,
+        delayMs: delay,
+        status: isProviderErr ? err.status : 0,
+        description,
+        ...providerErrorBody ? { errorBody: providerErrorBody } : {}
+      });
+      await new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+          clearTimeout(t);
+          signal.removeEventListener("abort", onAbort);
+        };
+        const onAbort = () => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(new Error("aborted"));
+        };
+        const t = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve();
+        }, delay);
+        if (signal.aborted) {
+          onAbort();
+          return;
+        }
+        signal.addEventListener("abort", onAbort);
+      });
+      attempt++;
+    }
+  }
+}
+function elapsedMs(startedNs) {
+  return Number(process.hrtime.bigint() - startedNs) / 1e6;
+}
+
+// src/core/fallback-model.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+function fallbackProfileChain(config, profileName) {
+  if (!profileName) return [];
+  const mgr = new FallbackProfileManager(config);
+  return mgr.resolve(profileName).map((e) => `${e.providerId}/${e.model}`);
+}
+function shouldFallback(err) {
+  if (err instanceof ProviderError || ProviderError.isProviderError(err)) {
+    const kind = err.kind;
+    return isFallbackWorthy(kind) ? err.status : null;
+  }
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    if (msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("fetch failed") || msg.includes("failed to fetch") || msg.includes("network") || msg.includes("timeout") || msg.includes("503") || msg.includes("502") || msg.includes("504") || msg.includes("overloaded") || msg.includes("rate limit") || msg.includes("quota")) {
+      return 503;
+    }
+  }
+  return null;
+}
+function isUsableModelResponse(response) {
+  if (!response?.content) return void 0;
+  return response.content.some(
+    (block) => isToolUseBlock(block) || isTextBlock(block) && block.text.trim().length > 0
+  );
+}
+function ensureUsableModelResponse(response, providerId, model) {
+  const usable = isUsableModelResponse(response);
+  if (usable !== false) return response;
+  throw new ProviderError(
+    `Empty response from ${providerId}/${model}; trying the next configured model`,
+    503,
+    true,
+    providerId,
+    { kind: "overloaded" }
+  );
+}
+function smartDefaultFallbackChain(config) {
+  const mgr = new FallbackProfileManager(config);
+  return mgr.resolveEffective({ fallbackAuto: true }).map((e) => `${e.providerId}/${e.model}`);
+}
+function effectiveFallbackChain(config) {
+  const mgr = new FallbackProfileManager(config);
+  return mgr.resolveEffective({
+    fallbackModels: config.fallbackModels,
+    fallbackProfile: config.fallbackProfile,
+    fallbackAuto: config.fallbackAuto
+  }).map((e) => `${e.providerId}/${e.model}`);
+}
+function runtimeFallbackChain(config) {
+  const mgr = new FallbackProfileManager(config);
+  const current = primaryTarget(config);
+  return mgr.resolveCandidates(current, {}).map((e) => `${e.providerId}/${e.model}`);
+}
+var DEFAULT_PRIMARY_COOLDOWN_MS = 6e4;
+var DEFAULT_PRIMARY_COOLDOWN_MAX_MS = 10 * 6e4;
+var DEFAULT_PRIMARY_RECOVERY_SUCCESSES = 2;
+function sameTarget(a, b) {
+  return !!a && a.providerId === b.providerId && a.model === b.model;
+}
+function fallbackCandidates(config, current, opts = {}) {
+  const mgr = opts.sharedManager ?? new FallbackProfileManager(config);
+  return mgr.resolveCandidates(current, {
+    fallbackModels: opts.fallbackModels,
+    fallbackProfile: opts.fallbackProfile,
+    primary: opts.primary ?? primaryTarget(config),
+    closedWorld: opts.closedWorld
+  });
+}
+var primaryTarget = (cfg) => ({ providerId: cfg.provider, model: cfg.model });
+function maxContextOf(provider) {
+  const max = provider.capabilities.maxContext;
+  return typeof max === "number" && Number.isFinite(max) ? max : 0;
+}
+function contextWindowWarning(currentProvider, nextProvider, currentTokens) {
+  const fromMaxContext = maxContextOf(currentProvider);
+  const toMaxContext = maxContextOf(nextProvider);
+  if (fromMaxContext <= 0 || toMaxContext <= 0 || toMaxContext >= fromMaxContext) return void 0;
+  return {
+    fromMaxContext,
+    toMaxContext,
+    ...typeof currentTokens === "number" && currentTokens > 0 ? { currentTokens } : {}
+  };
+}
+function createFallbackModelExtension(deps) {
+  let dirty = false;
+  let primaryFailureStreak = 0;
+  let primaryRecoveryHits = 0;
+  let stickyTurnsElapsed = 0;
+  let lastWorkingFallback;
+  let blockedPrimary;
+  let primaryBlockedUntil = 0;
+  const now = () => deps.now?.() ?? Date.now();
+  const liveStickiness = () => deps.getConfig().fallbackStickiness;
+  const cooldownBase = () => Math.max(
+    0,
+    deps.primaryCooldownMs ?? liveStickiness()?.primaryProbeInterval ?? DEFAULT_PRIMARY_COOLDOWN_MS
+  );
+  const cooldownMax = () => Math.max(cooldownBase(), deps.primaryCooldownMaxMs ?? DEFAULT_PRIMARY_COOLDOWN_MAX_MS);
+  const selectedPrimary = (cfg) => deps.getPrimaryTarget?.() ?? primaryTarget(cfg);
+  const primaryInCooldown = (cfg) => sameTarget(blockedPrimary, selectedPrimary(cfg)) && now() < primaryBlockedUntil;
+  const markPrimaryFailure = (cfg) => {
+    const primary = selectedPrimary(cfg);
+    primaryFailureStreak = sameTarget(blockedPrimary, primary) ? primaryFailureStreak + 1 : 1;
+    primaryRecoveryHits = 0;
+    stickyTurnsElapsed = 0;
+    blockedPrimary = primary;
+    const base = cooldownBase();
+    if (base <= 0) {
+      primaryBlockedUntil = 0;
+      return;
+    }
+    const multiplier = 2 ** Math.max(0, primaryFailureStreak - 1);
+    primaryBlockedUntil = now() + Math.min(cooldownMax(), base * multiplier);
+  };
+  const recoveryTarget = () => Math.max(1, deps.primaryRecoverySuccesses ?? DEFAULT_PRIMARY_RECOVERY_SUCCESSES);
+  const stickyTarget = () => Math.max(0, deps.stickyFallbackTurns ?? liveStickiness()?.stickyFallbackTurns ?? 0);
+  const inStickyWindow = () => stickyTurnsElapsed < stickyTarget();
+  const onPrimarySuccess = (cfg) => {
+    if (!sameTarget(blockedPrimary, selectedPrimary(cfg))) return;
+    primaryRecoveryHits += 1;
+    if (primaryRecoveryHits >= recoveryTarget()) {
+      primaryFailureStreak = 0;
+      primaryRecoveryHits = 0;
+      stickyTurnsElapsed = 0;
+      lastWorkingFallback = void 0;
+      blockedPrimary = void 0;
+      primaryBlockedUntil = 0;
+    } else {
+      primaryBlockedUntil = 0;
+    }
+  };
+  return {
+    name: "fallback-model",
+    beforeRun: async (ctx) => {
+      if (!dirty) return;
+      const cfg = deps.getConfig();
+      const primary = selectedPrimary(cfg);
+      stickyTurnsElapsed += 1;
+      if (inStickyWindow()) return;
+      if (primaryInCooldown(cfg)) return;
+      if (!evaluateModelCalendar(cfg.modelAvailabilitySchedule, primary.providerId, primary.model).allowed || deps.statusTracker && !deps.statusTracker.isAvailable(primary.providerId, primary.model))
+        return;
+      try {
+        const primaryProvider = await deps.buildProvider(primary.providerId, primary.model);
+        const currentTokens = ctx.lastRequestTokens;
+        const maxContext = maxContextOf(primaryProvider);
+        if (maxContext > 0 && typeof currentTokens === "number" && currentTokens > maxContext) {
+          deps.events.emit("provider.primary_probe_context_blocked", {
+            sessionId: resolveEventSessionId(ctx),
+            providerId: primary.providerId,
+            model: primary.model,
+            currentTokens,
+            maxContext,
+            timestamp: now()
+          });
+          deps.logger?.warn(
+            `fallback-model: deferring primary probe "${primary.providerId}/${primary.model}" \u2014 context (${currentTokens}) exceeds target window (${maxContext})`
+          );
+          markPrimaryFailure(cfg);
+          return;
+        }
+        ctx.provider = primaryProvider;
+        ctx.model = primary.model;
+        await deps.onModelSwitch?.(primary.providerId, primary.model);
+        primaryBlockedUntil = 0;
+      } catch (err) {
+        deps.logger?.warn(
+          `fallback-model: could not restore primary "${primary.providerId}/${primary.model}": ${err instanceof Error ? err.message : String(err)}`
+        );
+        markPrimaryFailure(cfg);
+        return;
+      }
+      dirty = false;
+    },
+    wrapProviderRunner: async (ctx, request, inner) => {
+      const tracker = deps.statusTracker;
+      const calendar = evaluateModelCalendar(
+        deps.getConfig().modelAvailabilitySchedule,
+        ctx.provider.id,
+        ctx.model
+      );
+      const trackerBlocked = tracker ? !tracker.isAvailable(ctx.provider.id, ctx.model) : false;
+      if (trackerBlocked || !calendar.allowed) {
+        deps.logger?.warn(
+          `provider-status: "${ctx.provider.id}/${ctx.model}" is blocked \u2014 trying fallback chain`
+        );
+        const status = tracker?.getStatus(ctx.provider.id, ctx.model);
+        const logical = tracker?.logicalIdentity(ctx.provider.id, ctx.model) ?? logicalCalendarTarget(ctx.provider.id, ctx.model);
+        deps.events.emit("provider.active_blocked", {
+          providerId: logical.providerId,
+          model: logical.model,
+          state: "blocked",
+          fallbackProviderId: "",
+          fallbackModel: "",
+          lastError: calendar.rule?.label ?? (calendar.rule ? "Blocked by model availability calendar" : void 0) ?? status?.lastErrorMessage ?? "Rate limit or repeated failures",
+          sessionId: resolveEventSessionId(ctx),
+          timestamp: Date.now()
+        });
+        const skipErr = new ProviderError(
+          `Skipping unavailable "${ctx.provider.id}/${ctx.model}" \u2014 try fallback`,
+          429,
+          true,
+          ctx.provider.id,
+          { kind: "rate_limit" }
+        );
+        return runFallbackChain(ctx, request, inner, skipErr, true);
+      }
+      try {
+        const response = ensureUsableModelResponse(
+          await inner(ctx, request),
+          ctx.provider.id,
+          ctx.model
+        );
+        tracker?.recordSuccess(ctx.provider.id, ctx.model, {
+          sessionId: resolveEventSessionId(ctx),
+          agentId: ctx.agentId
+        });
+        const cfg = deps.getConfig();
+        const primary = selectedPrimary(cfg);
+        if (ctx.provider.id === primary.providerId && ctx.model === primary.model) {
+          onPrimarySuccess(cfg);
+        }
+        return response;
+      } catch (firstErr) {
+        return runFallbackChain(ctx, request, inner, firstErr);
+      }
+      async function runFallbackChain(ctx_, request_, inner_, firstErr_, alreadyTracked = false) {
+        if (ctx_.signal?.aborted) throw firstErr_;
+        let lastErr = firstErr_;
+        const cfg = deps.getConfig();
+        const current = { providerId: ctx_.provider.id, model: ctx_.model };
+        const firstErrIsProvider = firstErr_ instanceof ProviderError || ProviderError.isProviderError(firstErr_);
+        if (!alreadyTracked && firstErrIsProvider && tracker && !isProviderFailureTracked(firstErr_)) {
+          tracker.recordFailure(
+            ctx_.provider.id,
+            ctx_.model,
+            firstErr_.kind,
+            firstErr_.status,
+            firstErr_.describe(),
+            {
+              sessionId: resolveEventSessionId(ctx_),
+              agentId: ctx_.agentId,
+              retryAfterMs: firstErr_.body?.retryAfterMs
+            }
+          );
+        }
+        const chain = fallbackCandidates(cfg, current, {
+          fallbackModels: deps.getFallbackModels?.(),
+          fallbackProfile: deps.getFallbackProfile?.(),
+          sharedManager: deps.fallbackProfileManager,
+          primary: selectedPrimary(cfg),
+          closedWorld: deps.isClosedWorld?.() ?? false
+        });
+        let usableChain = tracker ? chain.filter((e) => tracker.isAvailable(e.providerId, e.model)) : chain;
+        usableChain = usableChain.filter(
+          (e) => evaluateModelCalendar(cfg.modelAvailabilitySchedule, e.providerId, e.model).allowed
+        );
+        if (lastWorkingFallback && usableChain.length > 1 && // Don't front-load if the last-working is the current model
+        // (we're already on it) or if it's now blocked.
+        !(lastWorkingFallback.providerId === current.providerId && lastWorkingFallback.model === current.model) && !(tracker && !tracker.isAvailable(lastWorkingFallback.providerId, lastWorkingFallback.model))) {
+          const lwfKey = `${lastWorkingFallback.providerId}/${lastWorkingFallback.model}`;
+          const lwfEntry = usableChain.find((e) => `${e.providerId}/${e.model}` === lwfKey);
+          if (lwfEntry) {
+            usableChain = [
+              lwfEntry,
+              ...usableChain.filter((e) => `${e.providerId}/${e.model}` !== lwfKey)
+            ];
+          }
+        }
+        if (!alreadyTracked && shouldFallback(firstErr_) !== null && sameTarget(selectedPrimary(cfg), current)) {
+          markPrimaryFailure(cfg);
+        }
+        const status = shouldFallback(firstErr_);
+        if (status === null) throw firstErr_;
+        let gateRequestId;
+        const configuredGateSeconds = cfg.fallbackGateSeconds ?? deps.fallbackGateSeconds;
+        if (configuredGateSeconds !== 0 && deps.fallbackGate && usableChain.length > 0) {
+          gateRequestId = randomUUID3();
+          const autoSwitchSeconds = Math.max(1, configuredGateSeconds ?? 7);
+          const gateCandidates = usableChain.map((e) => ({
+            providerId: e.providerId,
+            model: e.model
+          }));
+          try {
+            const choice = await deps.fallbackGate({
+              events: deps.events,
+              sessionId: resolveEventSessionId(ctx_),
+              from: {
+                providerId: ctx_.provider.id,
+                model: ctx_.model
+              },
+              status,
+              candidates: gateCandidates,
+              autoSwitchSeconds,
+              requestId: gateRequestId
+            });
+            if (choice) {
+              const chosen = usableChain.find(
+                (e) => e.providerId === choice.providerId && e.model === choice.model
+              );
+              if (chosen) {
+                usableChain = [
+                  chosen,
+                  ...usableChain.filter(
+                    (e) => !(e.providerId === choice.providerId && e.model === choice.model)
+                  )
+                ];
+              }
+            }
+          } catch (gateErr) {
+            deps.logger?.warn(
+              `fallback-model: gate error \u2014 proceeding with default chain: ${gateErr instanceof Error ? gateErr.message : String(gateErr)}`
+            );
+          }
+        }
+        if (ctx_.signal?.aborted) throw firstErr_;
+        for (const entry of usableChain) {
+          if (ctx_.signal?.aborted) throw lastErr;
+          if (!evaluateModelCalendar(cfg.modelAvailabilitySchedule, entry.providerId, entry.model).allowed)
+            continue;
+          if (tracker && !tracker.isAvailable(entry.providerId, entry.model)) {
+            deps.logger?.warn(
+              `provider-status: "${entry.providerId}/${entry.model}" entered the waiting room since the chain was computed \u2014 skipping`
+            );
+            continue;
+          }
+          const targetProviderId = entry.providerId;
+          const targetModel = entry.model;
+          if (targetProviderId === ctx_.provider.id && targetModel === ctx_.model) continue;
+          if (primaryInCooldown(cfg) && sameTarget(selectedPrimary(cfg), {
+            providerId: targetProviderId,
+            model: targetModel
+          })) {
+            continue;
+          }
+          const from = { providerId: ctx_.provider.id, model: ctx_.model };
+          const logicalFrom = tracker?.logicalIdentity(from.providerId, from.model) ?? from;
+          let nextProvider;
+          try {
+            nextProvider = await deps.buildProvider(targetProviderId, targetModel);
+          } catch (err) {
+            deps.logger?.warn(
+              `fallback-model: skipping "${targetProviderId}/${targetModel}" \u2014 cannot build provider "${targetProviderId}": ${err instanceof Error ? err.message : String(err)}`
+            );
+            continue;
+          }
+          const entryMaxContext = maxContextOf(nextProvider);
+          const currentTokens = ctx_.lastRequestTokens;
+          if (entryMaxContext > 0 && typeof currentTokens === "number" && currentTokens > 0 && currentTokens > entryMaxContext) {
+            deps.logger?.warn(
+              `fallback-model: skipping "${targetProviderId}/${targetModel}" \u2014 context window (${entryMaxContext}) is smaller than current request tokens (${currentTokens})`
+            );
+            continue;
+          }
+          const providerSwitched = nextProvider.id !== from.providerId;
+          const warning = contextWindowWarning(ctx_.provider, nextProvider, ctx_.lastRequestTokens);
+          ctx_.provider = nextProvider;
+          ctx_.model = targetModel;
+          request_.model = targetModel;
+          bindRequestProvider(request_, nextProvider);
+          dirty = true;
+          await deps.onModelSwitch?.(targetProviderId, targetModel);
+          deps.events.emit("provider.fallback", {
+            sessionId: resolveEventSessionId(ctx_),
+            from: logicalFrom,
+            to: tracker?.logicalIdentity(nextProvider.id, targetModel) ?? {
+              providerId: nextProvider.id,
+              model: targetModel
+            },
+            status,
+            providerSwitched,
+            // Correlate this completion with the gate that paused for the
+            // user's pick — clients clear the fallback modal only when the
+            // requestId matches the pending request.
+            ...gateRequestId ? { requestId: gateRequestId } : {},
+            ...warning ? { contextWindowWarning: warning } : {}
+          });
+          if (ctx_.signal?.aborted) throw lastErr;
+          try {
+            const response = ensureUsableModelResponse(
+              await inner_(ctx_, request_),
+              ctx_.provider.id,
+              ctx_.model
+            );
+            tracker?.recordSuccess(nextProvider.id, targetModel, {
+              sessionId: resolveEventSessionId(ctx_),
+              agentId: ctx_.agentId
+            });
+            lastWorkingFallback = { providerId: nextProvider.id, model: targetModel };
+            return response;
+          } catch (err) {
+            if ((err instanceof ProviderError || ProviderError.isProviderError(err)) && tracker && !isProviderFailureTracked(err)) {
+              tracker.recordFailure(
+                nextProvider.id,
+                targetModel,
+                err.kind,
+                err.status,
+                err.describe(),
+                {
+                  sessionId: resolveEventSessionId(ctx_),
+                  agentId: ctx_.agentId,
+                  retryAfterMs: err.body?.retryAfterMs
+                }
+              );
+            }
+            lastErr = err;
+          }
+        }
+        throw lastErr;
+      }
+    }
+  };
+}
+
+export {
+  runProviderWithRetry,
+  fallbackProfileChain,
+  smartDefaultFallbackChain,
+  effectiveFallbackChain,
+  runtimeFallbackChain,
+  createFallbackModelExtension
+};
+//# sourceMappingURL=chunk-U45AXT5D.js.map