@linghun/tui 0.1.0

package/dist/chunk-WHFDDZHY.js

@@ -0,0 +1,407 @@
+import {
+  createCompactBoundaryBlock
+} from "./chunk-AKPXMCVF.js";
+import {
+  createEvidenceRecord,
+  rememberEvidence
+} from "./chunk-64MJP6FK.js";
+import {
+  applyToolResultBudgetToMessages
+} from "./chunk-O7S3HYE6.js";
+import {
+  injectDeepCompactSummary,
+  maybeRunDeepCompactBeforeProvider
+} from "./chunk-RMLTVKOY.js";
+import {
+  getContextWindowForModel
+} from "./chunk-K4FSYBSY.js";
+import {
+  getRoleRoute
+} from "./chunk-2YL5VKJ5.js";
+import {
+  compactMessagesToFit
+} from "./chunk-URNQUECO.js";
+import {
+  estimateModelMessageChars
+} from "./chunk-WV6YJGZR.js";
+import {
+  sanitizeDiagnosticText,
+  sanitizeDisplayPaths,
+  truncateDisplay
+} from "./chunk-OMZYPQVA.js";
+
+// src/compact-preflight-runtime.ts
+import "@linghun/providers";
+import { redactCommonSecrets } from "@linghun/shared";
+var MAX_CONTEXT_MESSAGES = 12;
+var CONTEXT_INPUT_HEADROOM_TOKENS = 8192;
+var CONTEXT_CHARS_PER_TOKEN_ESTIMATE = 4;
+var AUTOCOMPACT_BUFFER_TOKENS = 13e3;
+var LARGE_CONTEXT_BUFFER_TOKENS = 3e4;
+var HUGE_CONTEXT_BUFFER_TOKENS = 5e4;
+var LARGE_CONTEXT_WINDOW_TOKENS = 4e5;
+var HUGE_CONTEXT_WINDOW_TOKENS = 8e5;
+var COMPACT_FAILURE_COOLDOWN_MS = 2 * 60 * 1e3;
+var COMPACT_SUMMARY_MAX_CHARS = 3200;
+var COMPACT_SUMMARY_TARGET_RESERVE_CHARS = 4e3;
+var COMPACT_PROJECTION_EVENT_PREFIX = "compact_projection:";
+var MAX_COMPACT_BOUNDARIES = 20;
+async function prepareMessagesForProviderPreflight(input) {
+  const budgeted = await prepareMessagesForProviderWithToolResultBudget(
+    input.messages,
+    input.context,
+    input.sessionId,
+    input.deps
+  );
+  const contextMaxChars = getProviderContextMaxChars(input.context, input.runtime);
+  const triggerChars = getAutoCompactTriggerChars(input.context, input.runtime);
+  const currentChars = estimateModelMessageChars(budgeted);
+  if (currentChars <= triggerChars) {
+    const withDeep = injectDeepCompactSummary(budgeted, input.context.cache.deepCompact);
+    if (estimateModelMessageChars(withDeep) <= contextMaxChars) {
+      return { blocked: false, messages: withDeep };
+    }
+  }
+  const now = Date.now();
+  if (input.context.cache.compactCooldownUntil && input.context.cache.compactCooldownUntil > now) {
+    const message = input.context.language === "en-US" ? "Context compact is cooling down after a previous failure. I will not send an oversized partial context to the provider; retry after the cooldown or run /compact status." : "\u4E0A\u4E00\u6B21\u4E0A\u4E0B\u6587\u538B\u7F29\u5931\u8D25\u540E\u4ECD\u5728\u51B7\u5374\u4E2D\u3002\u6211\u4E0D\u4F1A\u628A\u8D85\u538B\u7684\u534A\u622A\u4E0A\u4E0B\u6587\u7EE7\u7EED\u53D1\u7ED9 provider\uFF1B\u8BF7\u7A0D\u540E\u91CD\u8BD5\u6216\u8FD0\u884C /compact status \u67E5\u770B\u3002";
+    await input.deps.appendSystemEvent(
+      input.context,
+      input.sessionId,
+      "context_compact_cooldown_active",
+      "warning"
+    );
+    return { blocked: true, messages: budgeted, message };
+  }
+  const pairing = inspectToolPairingSafety(budgeted);
+  if (!pairing.safe) {
+    await input.deps.appendSystemEvent(
+      input.context,
+      input.sessionId,
+      `context_compact_skipped_tool_pairing: pending=${pairing.pending} orphan=${pairing.orphan} duplicate=${pairing.duplicate}`,
+      "warning"
+    );
+    if (currentChars > contextMaxChars) {
+      await recordCompactFailure(
+        input.context,
+        input.sessionId,
+        "tool_pairing_unsafe_over_context_limit",
+        true,
+        input.deps
+      );
+      const message = input.context.language === "en-US" ? "Context pressure is over the provider limit, but an unfinished tool pair makes compact unsafe. This provider request is blocked." : "\u5F53\u524D\u4E0A\u4E0B\u6587\u5DF2\u8D85\u8FC7 provider \u4E0A\u9650\uFF0C\u4F46\u5B58\u5728\u672A\u95ED\u5408 tool pair\uFF0C\u538B\u7F29\u4E0D\u5B89\u5168\u3002\u672C\u6B21 provider \u8BF7\u6C42\u5DF2\u963B\u65AD\u3002";
+      return { blocked: true, messages: budgeted, message };
+    }
+    return { blocked: false, messages: budgeted };
+  }
+  try {
+    if (input.deps.runDeepCompact) {
+      const deep = await maybeRunDeepCompactBeforeProvider({
+        context: input.context,
+        sessionId: input.sessionId,
+        runtime: input.runtime,
+        trigger: input.trigger,
+        gateway: input.context.modelGateway,
+        signal: input.context.activeAbortController?.signal,
+        deps: input.deps.runDeepCompact
+      });
+      if (!deep.ok) {
+        await recordCompactFailure(
+          input.context,
+          input.sessionId,
+          `deep_compact_failed:${deep.message}`,
+          true,
+          input.deps
+        );
+        return { blocked: true, messages: budgeted, message: deep.message };
+      }
+    }
+    const compacted = compactMessagesToFit(budgeted, {
+      maxChars: Math.max(1, triggerChars - COMPACT_SUMMARY_TARGET_RESERVE_CHARS),
+      preserveRecentMessages: MAX_CONTEXT_MESSAGES,
+      kind: "micro"
+    });
+    if (!compacted.changed || !compacted.boundary) {
+      return { blocked: false, messages: budgeted };
+    }
+    const projection = createCompactProjection(input.context, {
+      boundary: compacted.boundary,
+      originalMessages: budgeted,
+      compactedMessages: compacted.messages,
+      contextMaxChars,
+      triggerChars,
+      trigger: input.trigger,
+      pairingSafe: pairing.safe
+    });
+    const providerMessages = injectDeepCompactSummary(
+      injectCompactProjectionMessage(compacted.messages, projection),
+      input.context.cache.deepCompact
+    );
+    if (estimateModelMessageChars(providerMessages) > contextMaxChars) {
+      await recordCompactFailure(
+        input.context,
+        input.sessionId,
+        "post_compact_summary_over_context_limit",
+        true,
+        input.deps
+      );
+      const message = input.context.language === "en-US" ? "Context compact summary still exceeds the provider limit, so the request is blocked." : "\u4E0A\u4E0B\u6587\u538B\u7F29\u6458\u8981\u540E\u4ECD\u8D85\u8FC7 provider \u4E0A\u9650\uFF0C\u672C\u6B21\u8BF7\u6C42\u5DF2\u963B\u65AD\u3002";
+      return { blocked: true, messages: budgeted, message };
+    }
+    if (!inspectToolPairingSafety(providerMessages).safe) {
+      await recordCompactFailure(
+        input.context,
+        input.sessionId,
+        "post_compact_pairing_unsafe",
+        true,
+        input.deps
+      );
+      const message = input.context.language === "en-US" ? "Context compact produced an unsafe tool pairing boundary, so the provider request is blocked." : "\u4E0A\u4E0B\u6587\u538B\u7F29\u540E\u7684 tool pairing \u8FB9\u754C\u4E0D\u5B89\u5168\uFF0C\u672C\u6B21 provider \u8BF7\u6C42\u5DF2\u963B\u65AD\u3002";
+      return { blocked: true, messages: budgeted, message };
+    }
+    recordCompactBoundary(input.context, compacted.boundary);
+    input.context.cache.compactProjection = projection;
+    input.context.cache.compactFailure = void 0;
+    input.context.cache.compactCooldownUntil = void 0;
+    input.deps.refreshCacheFreshness(input.context);
+    input.context.pushTranscriptBlock?.(
+      createCompactBoundaryBlock(
+        projection.preCompactChars,
+        projection.postCompactChars,
+        input.context.language
+      )
+    );
+    await appendCompactProjectionEvents(input.context, input.sessionId, projection, input.deps);
+    return { blocked: false, messages: providerMessages };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    await recordCompactFailure(input.context, input.sessionId, reason, true, input.deps);
+    const message = input.context.language === "en-US" ? "Context compact failed, so this provider request is blocked instead of continuing with partial context." : "\u4E0A\u4E0B\u6587\u538B\u7F29\u5931\u8D25\uFF0C\u672C\u6B21 provider \u8BF7\u6C42\u5DF2\u963B\u65AD\uFF0C\u4E0D\u4F1A\u62FF\u534A\u622A\u4E0A\u4E0B\u6587\u7EE7\u7EED\u8FD0\u884C\u3002";
+    return { blocked: true, messages: budgeted, message };
+  }
+}
+async function prepareMessagesForProviderWithToolResultBudget(messages, context, sessionId, deps) {
+  const budgeted = await applyToolResultBudgetToMessages(messages, {
+    projectPath: context.projectPath,
+    sessionId,
+    state: getToolResultBudgetState(context)
+  });
+  for (const record of budgeted.records) {
+    await deps.recordToolResultBudgetEvidence(context, sessionId, record);
+  }
+  return budgeted.messages;
+}
+function getToolResultBudgetState(context) {
+  context.toolResultBudgetState ??= { seenIds: /* @__PURE__ */ new Set(), replacements: /* @__PURE__ */ new Map() };
+  return context.toolResultBudgetState;
+}
+function recordCompactBoundary(context, boundary) {
+  context.cache.compacted = true;
+  context.cache.compactBoundaries.push(boundary);
+  if (context.cache.compactBoundaries.length > MAX_COMPACT_BOUNDARIES) {
+    context.cache.compactBoundaries.shift();
+  }
+  void context.compactOutputMemory?.();
+}
+function getAutoCompactBufferTokens(context, runtime) {
+  const route = getRoleRoute(context.config, runtime.role);
+  const contextWindowTokens = getContextWindowForModel(runtime.model, route);
+  if (contextWindowTokens >= HUGE_CONTEXT_WINDOW_TOKENS) {
+    return HUGE_CONTEXT_BUFFER_TOKENS;
+  }
+  if (contextWindowTokens >= LARGE_CONTEXT_WINDOW_TOKENS) {
+    return LARGE_CONTEXT_BUFFER_TOKENS;
+  }
+  return AUTOCOMPACT_BUFFER_TOKENS;
+}
+function getAutoCompactTriggerChars(context, runtime) {
+  const maxChars = getProviderContextMaxChars(context, runtime);
+  const bufferChars = getAutoCompactBufferTokens(context, runtime) * CONTEXT_CHARS_PER_TOKEN_ESTIMATE;
+  return Math.max(1, maxChars - bufferChars);
+}
+function inspectToolPairingSafety(messages) {
+  const pending = /* @__PURE__ */ new Set();
+  const seenResults = /* @__PURE__ */ new Set();
+  let orphan = 0;
+  let duplicate = 0;
+  for (const message of messages) {
+    if (message.role === "assistant") {
+      for (const toolCall of message.toolCalls ?? []) {
+        if (pending.has(toolCall.id)) {
+          duplicate += 1;
+          continue;
+        }
+        pending.add(toolCall.id);
+      }
+      continue;
+    }
+    if (message.role === "tool") {
+      if (!pending.has(message.tool_call_id)) {
+        orphan += 1;
+        continue;
+      }
+      if (seenResults.has(message.tool_call_id)) {
+        duplicate += 1;
+        continue;
+      }
+      pending.delete(message.tool_call_id);
+      seenResults.add(message.tool_call_id);
+    }
+  }
+  return {
+    safe: pending.size === 0 && orphan === 0 && duplicate === 0,
+    pending: pending.size,
+    orphan,
+    duplicate
+  };
+}
+function createCompactProjection(context, input) {
+  const preCompactChars = estimateModelMessageChars(input.originalMessages);
+  const postCompactChars = estimateModelMessageChars(input.compactedMessages);
+  const removedMessages = Math.max(
+    0,
+    input.originalMessages.length - input.compactedMessages.length
+  );
+  const activeAgents = context.agents.filter((agent) => agent.status === "running").slice(0, 5).map(
+    (agent) => `${agent.id}:${agent.status}:${sanitizeCompactSummaryText(context, agent.summary || agent.task, 80)}`
+  );
+  const activeWorkflows = context.backgroundTasks.filter((task) => task.kind === "job" || task.kind === "agent").filter((task) => task.status === "running").slice(0, 5).map(
+    (task) => `${task.kind}:${task.status}:${sanitizeCompactSummaryText(context, task.userVisibleSummary, 80)}`
+  );
+  const needsAttentionWorkflows = context.backgroundTasks.filter((task) => task.kind === "job" || task.kind === "agent").filter((task) => task.status === "paused" || task.status === "blocked").slice(0, 5).map(
+    (task) => `${task.kind}:${task.status}:${sanitizeCompactSummaryText(context, task.userVisibleSummary, 80)}`
+  );
+  const staleResumableWorkflows = context.backgroundTasks.filter((task) => task.kind === "job" || task.kind === "agent").filter((task) => task.status === "stale").slice(0, 5).map(
+    (task) => `${task.kind}:${task.status}:${sanitizeCompactSummaryText(context, task.userVisibleSummary, 80)}`
+  );
+  const pending = [
+    context.pendingLocalApproval ? "local approval pending" : "",
+    context.pendingNaturalCommand ? "natural command pending" : "",
+    context.pendingAutopilot ? "autopilot pending" : ""
+  ].filter(Boolean);
+  const failureLearning = context.failureLearning.records.slice(0, 3).map(
+    (record) => `${record.id}:${sanitizeCompactSummaryText(context, record.failureSummary, 100)}`
+  );
+  const evidenceRefs = context.evidence.slice(0, 8).map((item) => item.id);
+  const files = [
+    .../* @__PURE__ */ new Set([
+      ...context.recentlyMentionedFiles.slice(0, 8),
+      ...context.tools.changedFiles.slice(0, 8),
+      ...input.boundary.preservedFiles.slice(0, 8)
+    ])
+  ].map((file) => sanitizeCompactSummaryText(context, file, 120)).slice(0, 12);
+  const risks = [
+    removedMessages > 0 ? `${removedMessages} older provider messages replaced by summary` : "",
+    input.boundary.compactedToolResultIds.length > 0 ? `${input.boundary.compactedToolResultIds.length} older tool results removed as complete pairs` : ""
+  ].filter(Boolean);
+  const summary = truncateDisplay(
+    [
+      "Linghun compact summary",
+      "scope provider-visible recent context projection",
+      `trigger ${input.trigger}`,
+      `user goal ${sanitizeCompactSummaryText(context, context.memory.lastHandoff?.goal ?? "current interactive coding task", 220)}`,
+      `current task ${sanitizeCompactSummaryText(context, context.tools.todos.find((todo) => todo.status !== "completed")?.content ?? "continue the latest user request", 220)}`,
+      `decisions ${context.routeDecisions.slice(0, 3).map(
+        (item) => `${item.role}:${item.selectedProvider || "paused"}/${item.selectedModel || "paused"}`
+      ).join("; ") || "none recorded"}`,
+      `files or evidence refs ${[...files, ...evidenceRefs.map((id) => `evidence:${id}`)].join(", ") || "none"}`,
+      `active agents/workflows ${[...activeAgents, ...activeWorkflows].join("; ") || "none"}`,
+      `needs-attention agents/workflows ${needsAttentionWorkflows.join("; ") || "none"}`,
+      `stale resumable agents/workflows ${staleResumableWorkflows.join("; ") || "none"}`,
+      `pending permissions/tool calls ${pending.join("; ") || "none"}`,
+      `failure learning ${failureLearning.join("; ") || "none"}`,
+      "anti hallucination: do not claim compact failure as PASS evidence; preserve evidence-bound claims only",
+      `index/cache/memory freshness: index ${context.index.status}; cache freshness ${context.cache.lastFreshness?.changedKeys?.join(",") || "stable-or-unknown"}; memory ${context.memory.accepted.length} accepted`,
+      `discarded scope ${risks.join("; ") || "older provider-visible recent context summarized"}`,
+      `tool pairing safe ${input.pairingSafe ? "yes" : "no"}`
+    ].join("\n"),
+    COMPACT_SUMMARY_MAX_CHARS
+  );
+  return {
+    boundaryId: input.boundary.id,
+    createdAt: input.boundary.createdAt,
+    summary,
+    pressureRatio: Number((preCompactChars / Math.max(1, input.contextMaxChars)).toFixed(3)),
+    preCompactChars,
+    postCompactChars,
+    discardedRange: risks.join("; ") || "older provider-visible recent context summarized",
+    toolPairingSafe: input.pairingSafe,
+    risks,
+    evidenceRefs
+  };
+}
+function sanitizeCompactSummaryText(context, value, maxChars) {
+  const singleLine = value.replace(/\s+/g, " ");
+  const withoutSecrets = sanitizeDiagnosticText(redactCommonSecrets(singleLine));
+  return truncateDisplay(sanitizeDisplayPaths(withoutSecrets, context.projectPath), maxChars);
+}
+function injectCompactProjectionMessage(messages, projection) {
+  const summaryMessage = {
+    role: "user",
+    content: `[Context compact boundary ${projection.boundaryId}]
+${projection.summary}`
+  };
+  if (messages[0]?.role === "system") {
+    return [messages[0], summaryMessage, ...messages.slice(1)];
+  }
+  return [summaryMessage, ...messages];
+}
+async function appendCompactProjectionEvents(context, sessionId, projection, deps) {
+  await deps.appendSystemEvent(
+    context,
+    sessionId,
+    `${COMPACT_PROJECTION_EVENT_PREFIX}${JSON.stringify(projection)}`,
+    "info"
+  );
+  const evidence = createEvidenceRecord(
+    "user_provided",
+    `compact boundary ${projection.boundaryId}; scope provider-visible recent context projection; pressure ${projection.pressureRatio}; tool pairing safe ${projection.toolPairingSafe ? "yes" : "no"}`,
+    `compact:${projection.boundaryId}`,
+    ["context_compact_boundary"]
+  );
+  rememberEvidence(context, evidence);
+  await context.store.appendEvent(sessionId, { type: "evidence_record", ...evidence });
+}
+async function recordCompactFailure(context, sessionId, reason, blocked, deps) {
+  const cooldownUntilMs = Date.now() + COMPACT_FAILURE_COOLDOWN_MS;
+  context.cache.compactCooldownUntil = cooldownUntilMs;
+  context.cache.compactFailure = {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    reason: sanitizeCompactSummaryText(context, reason, 220),
+    blocked,
+    cooldownUntil: new Date(cooldownUntilMs).toISOString()
+  };
+  await deps.appendSystemEvent(
+    context,
+    sessionId,
+    `context compact failed: blocked ${blocked ? "yes" : "no"}; reason ${context.cache.compactFailure.reason}; cooldown until ${context.cache.compactFailure.cooldownUntil}`,
+    "warning"
+  );
+  await deps.captureFailureLearning(context, sessionId, {
+    category: "resource_cap",
+    failureSummary: "context compact failed before provider request",
+    rootCauseGuess: context.cache.compactFailure.reason,
+    avoidNextTime: "Do not continue with partial context after compact failure; retry after cooldown or reduce context pressure",
+    sourceRef: "system_event:context_compact_failed",
+    relatedTarget: "context compact",
+    severity: "medium"
+  });
+}
+function getProviderContextMaxChars(context, runtime) {
+  const route = getRoleRoute(context.config, runtime.role);
+  const contextWindow = getContextWindowForModel(runtime.model, route);
+  const maxInputTokens = route.maxInputTokens ?? Math.max(
+    1,
+    contextWindow - (route.maxOutputTokens ?? context.config.providers[runtime.provider]?.maxOutputTokens ?? CONTEXT_INPUT_HEADROOM_TOKENS)
+  );
+  return Math.max(1, maxInputTokens * CONTEXT_CHARS_PER_TOKEN_ESTIMATE);
+}
+
+export {
+  prepareMessagesForProviderPreflight,
+  recordCompactBoundary,
+  getAutoCompactTriggerChars,
+  inspectToolPairingSafety,
+  sanitizeCompactSummaryText,
+  getProviderContextMaxChars
+};

package/dist/chunk-WJWYRBWH.js

@@ -0,0 +1,48 @@
+import {
+  feishuBridgeAdapter,
+  feishuReceiveMessageToBridgeEvent
+} from "./chunk-CFXB5SE5.js";
+
+// src/feishu-long-connection-runtime.ts
+import * as Lark from "@larksuiteoapi/node-sdk";
+async function startFeishuLongConnection(options) {
+  if (!options.appId) throw new Error("Feishu long connection missing appId");
+  if (!options.appSecret) throw new Error("Feishu long connection missing appSecret");
+  const wsClient = new Lark.WSClient({
+    appId: options.appId,
+    appSecret: options.appSecret,
+    loggerLevel: Lark.LoggerLevel.error
+  });
+  const onMessage = async (data) => {
+    const event = feishuReceiveMessageToBridgeEvent(data, options.nowMs?.() ?? Date.now());
+    await options.onMessage(feishuBridgeAdapter(event));
+  };
+  const dispatcher = new Lark.EventDispatcher({}).register({
+    "im.message.receive_v1": onMessage
+  });
+  await wsClient.start({ eventDispatcher: dispatcher });
+  let closed = false;
+  let closePromise;
+  return {
+    close: async () => {
+      if (closed) {
+        await closePromise;
+        return;
+      }
+      closed = true;
+      dispatcher.handles.delete("im.message.receive_v1");
+      try {
+        wsClient.close({ force: true });
+        closePromise = Promise.resolve();
+      } catch (error) {
+        closePromise = Promise.reject(error);
+        throw error;
+      }
+      await closePromise;
+    }
+  };
+}
+
+export {
+  startFeishuLongConnection
+};

package/dist/chunk-WKMBK5UP.js

@@ -0,0 +1,145 @@
+import {
+  formatReasoningEffectiveState
+} from "./chunk-3LT6OWQ2.js";
+import {
+  getRoleRoute,
+  inferProviderForRouteModel
+} from "./chunk-2YL5VKJ5.js";
+import {
+  checkProviderCooldown,
+  formatCooldownMessage
+} from "./chunk-EBACIBJP.js";
+import {
+  classifyProviderFailure,
+  formatProviderFallbackAttemptSummary
+} from "./chunk-OZMX3E35.js";
+import {
+  writeLine
+} from "./chunk-OMZYPQVA.js";
+
+// src/provider-loop-runtime.ts
+import { randomUUID } from "crypto";
+import { resolveEffectiveEndpointProfile } from "@linghun/providers";
+function getProviderErrorCode(error) {
+  return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "PROVIDER_ERROR";
+}
+function shouldAttemptRuntimeFallback(kind) {
+  return kind === "rate_limit" || kind === "quota_or_balance_exhausted" || kind === "gateway" || kind === "transit" || kind === "timeout";
+}
+function createRuntimeForFallbackModel(context, baseRuntime, fallbackModel) {
+  if (!fallbackModel || fallbackModel === baseRuntime.model) return void 0;
+  const provider = inferProviderForRouteModel(fallbackModel, context.config);
+  const providerConfig = context.config.providers[provider];
+  if (!providerConfig) return void 0;
+  const rawEndpointProfile = providerConfig.endpointProfile ?? "chat_completions";
+  const endpointProfile = resolveEffectiveEndpointProfile({
+    requestEndpointProfile: void 0,
+    configEndpointProfile: rawEndpointProfile,
+    configBaseUrl: providerConfig.baseUrl,
+    configModel: providerConfig.model,
+    requestModel: fallbackModel
+  }).endpointProfile;
+  const compatibilityProfile = providerConfig.compatibilityProfile ?? (providerConfig.type === "deepseek" ? "deepseek" : "strict_openai_compatible");
+  const reasoningLevel = providerConfig.reasoningLevel;
+  const reasoningSent = Boolean(
+    reasoningLevel && (endpointProfile === "responses" || compatibilityProfile === "permissive_openai_compatible" || endpointProfile === "anthropic_messages")
+  );
+  return {
+    role: baseRuntime.role,
+    provider,
+    model: fallbackModel,
+    endpointProfile,
+    reasoningLevel,
+    reasoningStatus: formatReasoningEffectiveState(reasoningLevel, reasoningSent),
+    reasoningSent
+  };
+}
+function resolveRuntimeFallback(context, runtime, error) {
+  const kind = classifyProviderFailure(error);
+  if (!shouldAttemptRuntimeFallback(kind)) return void 0;
+  const route = getRoleRoute(context.config, runtime.role);
+  for (const fallbackModel of route.fallbackModels) {
+    const fallbackRuntime = createRuntimeForFallbackModel(context, runtime, fallbackModel);
+    if (!fallbackRuntime) continue;
+    if (fallbackRuntime.provider === runtime.provider && fallbackRuntime.model === runtime.model) {
+      continue;
+    }
+    return { runtime: fallbackRuntime, kind, code: getProviderErrorCode(error) };
+  }
+  return void 0;
+}
+async function recordProviderFallbackAttempt(context, sessionId, input) {
+  const summary = formatProviderFallbackAttemptSummary(
+    {
+      fromProvider: input.from.provider,
+      fromModel: input.from.model,
+      toProvider: input.to.provider,
+      toModel: input.to.model,
+      reasonKind: input.kind
+    },
+    context.language
+  );
+  context.lastProviderFallbackAttempt = {
+    fromProvider: input.from.provider,
+    fromModel: input.from.model,
+    toProvider: input.to.provider,
+    toModel: input.to.model,
+    reasonKind: input.kind,
+    reasonCode: input.code,
+    status: input.status,
+    summary,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const decision = context.routeDecisions.find(
+    (item) => item.role === input.from.role && item.selectedModel === input.from.model
+  );
+  if (decision) {
+    decision.fallbackUsed = true;
+  } else {
+    context.routeDecisions.unshift({
+      id: `route-${randomUUID().slice(0, 8)}`,
+      triggerReason: "provider runtime fallback",
+      role: input.from.role,
+      selectedProvider: input.to.provider,
+      selectedModel: input.to.model,
+      fallbackCandidates: [input.to.model],
+      requiredCapabilities: [],
+      stopConditions: [],
+      repairSuggestions: [],
+      fallbackUsed: true,
+      budgetStop: false,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  await context.store.appendEvent(sessionId, {
+    type: "system_event",
+    id: randomUUID(),
+    level: input.status === "succeeded" ? "info" : "warning",
+    message: `provider fallback attempt: from ${input.from.provider}/${input.from.model}; to ${input.to.provider}/${input.to.model}; reason ${input.kind}; code ${input.code}; status ${input.status}`,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function checkAndWriteProviderCooldown(context, runtime, output) {
+  const cooldownCheck = checkProviderCooldown(
+    context.providerBreaker,
+    runtime.provider,
+    runtime.model
+  );
+  if (!cooldownCheck.blocked) return false;
+  writeLine(
+    output,
+    formatCooldownMessage(
+      runtime.provider,
+      runtime.model,
+      cooldownCheck.remainingMs,
+      context.language
+    )
+  );
+  return true;
+}
+
+export {
+  resolveRuntimeFallback,
+  recordProviderFallbackAttempt,
+  checkAndWriteProviderCooldown
+};