@linghun/tui 0.1.0

package/dist/chunk-E72U7WW7.js

@@ -0,0 +1,50 @@
+// src/feature-flag-runtime.ts
+var DEFAULT_FEATURE_FLAGS = {
+  experimentalDeferredSkillExecution: false,
+  experimentalDeferredPluginExecution: false,
+  localReplBridge: true,
+  memoryIncludes: true,
+  customKeybindings: true
+};
+function getFeatureFlags(context) {
+  const raw = context?.config;
+  return {
+    ...DEFAULT_FEATURE_FLAGS,
+    ...raw?.features ? parseFeatureFlags(raw.features) : {},
+    ...parseFeatureFlagEnv()
+  };
+}
+function isFeatureEnabled(name, context) {
+  return getFeatureFlags(context)[name] === true;
+}
+function formatFeatureFlags(flags) {
+  return Object.entries(flags).sort(([left], [right]) => left.localeCompare(right)).map(([name, enabled]) => `- ${name}: ${enabled ? "enabled" : "disabled"}`);
+}
+function parseFeatureFlags(raw) {
+  const parsed = {};
+  for (const key of Object.keys(DEFAULT_FEATURE_FLAGS)) {
+    if (typeof raw[key] === "boolean") parsed[key] = raw[key];
+  }
+  return parsed;
+}
+function parseFeatureFlagEnv() {
+  const raw = process.env.LINGHUN_FEATURE_FLAGS;
+  if (!raw) return {};
+  const flags = {};
+  for (const item of raw.split(",")) {
+    const [name, value] = item.split("=").map((part) => part.trim());
+    if (!isFeatureFlagName(name)) continue;
+    flags[name] = value === "1" || value === "true" || value === "on";
+  }
+  return flags;
+}
+function isFeatureFlagName(value) {
+  return Boolean(value && value in DEFAULT_FEATURE_FLAGS);
+}
+
+export {
+  DEFAULT_FEATURE_FLAGS,
+  getFeatureFlags,
+  isFeatureEnabled,
+  formatFeatureFlags
+};

package/dist/chunk-EBACIBJP.js

@@ -0,0 +1,356 @@
+import {
+  classifyProviderFailure
+} from "./chunk-OZMX3E35.js";
+
+// src/provider-circuit-breaker.ts
+import { readPositiveIntEnv } from "@linghun/shared";
+import { LinghunError } from "@linghun/core";
+var BREAKER_FAILURE_THRESHOLD = 5;
+var BREAKER_COOLDOWN_MS = readPositiveIntEnv("LINGHUN_PROVIDER_BREAKER_COOLDOWN_MS", 12e4);
+var PROVIDER_ACTIVE_LIMIT = readPositiveIntEnv("LINGHUN_PROVIDER_ACTIVE_LIMIT", 3);
+var RECOVERABLE_CODES = /* @__PURE__ */ new Set([
+  "PROVIDER_SERVER_ERROR",
+  "PROVIDER_RATE_LIMITED",
+  "PROVIDER_REQUEST_TIMEOUT",
+  "PROVIDER_STREAM_TIMEOUT",
+  "PROVIDER_NETWORK_ERROR",
+  "PROVIDER_STREAM_ERROR",
+  "PROVIDER_STREAM_DECODE_ERROR",
+  "PROVIDER_RETRY_EXHAUSTED",
+  "PROVIDER_NON_SSE_STREAM",
+  "PROVIDER_MALFORMED_STREAM",
+  "PROVIDER_PARTIAL_TOOL_CALL",
+  "PROVIDER_QUOTA_EXHAUSTED"
+]);
+function createProviderCircuitBreakerState() {
+  return { entries: /* @__PURE__ */ new Map() };
+}
+function makeBreakerKey(providerId, model) {
+  return `${providerId}::${model}`;
+}
+function isRecoverableProviderFailure(errorCode) {
+  return RECOVERABLE_CODES.has(errorCode);
+}
+function checkProviderGate(state, providerId, model) {
+  const cooldown = checkProviderCooldown(state, providerId, model);
+  if (cooldown.blocked) {
+    return {
+      allowed: false,
+      reason: "cooldown",
+      remainingMs: cooldown.remainingMs,
+      reasonCode: cooldown.reasonCode
+    };
+  }
+  const key = makeBreakerKey(providerId, model);
+  const entry = state.entries.get(key);
+  const limit = entry?.activeLimit ?? PROVIDER_ACTIVE_LIMIT;
+  const count = entry?.activeCount ?? 0;
+  if (count >= limit) {
+    return { allowed: false, reason: "at_capacity", activeCount: count, activeLimit: limit };
+  }
+  return { allowed: true };
+}
+function acquireProviderSlot(state, providerId, model) {
+  const key = makeBreakerKey(providerId, model);
+  const existing = state.entries.get(key);
+  const limit = existing?.activeLimit ?? PROVIDER_ACTIVE_LIMIT;
+  const count = existing?.activeCount ?? 0;
+  if (count >= limit) return false;
+  state.entries.set(key, {
+    providerId,
+    model,
+    state: existing?.state ?? "closed",
+    consecutiveFailures: existing?.consecutiveFailures ?? 0,
+    lastFailureAt: existing?.lastFailureAt ?? 0,
+    cooldownUntil: existing?.cooldownUntil ?? 0,
+    reasonCode: existing?.reasonCode ?? "",
+    activeCount: count + 1,
+    activeLimit: limit
+  });
+  return true;
+}
+function releaseProviderSlot(state, providerId, model) {
+  const key = makeBreakerKey(providerId, model);
+  const existing = state.entries.get(key);
+  if (!existing) return;
+  const count = Math.max(0, existing.activeCount - 1);
+  if (count === 0 && existing.state === "closed" && existing.consecutiveFailures === 0 && existing.cooldownUntil === 0) {
+    state.entries.delete(key);
+  } else {
+    state.entries.set(key, { ...existing, activeCount: count });
+  }
+}
+function recordProviderFailure(state, providerId, model, errorCode) {
+  if (!isRecoverableProviderFailure(errorCode)) {
+    return false;
+  }
+  const key = makeBreakerKey(providerId, model);
+  const existing = state.entries.get(key);
+  const previousState = existing?.state ?? "closed";
+  const now = Date.now();
+  const consecutiveFailures = (existing?.consecutiveFailures ?? 0) + 1;
+  const cooldownUntil = consecutiveFailures >= BREAKER_FAILURE_THRESHOLD ? now + BREAKER_COOLDOWN_MS : 0;
+  const breakerState = cooldownUntil > 0 ? "open" : "closed";
+  state.entries.set(key, {
+    providerId,
+    model,
+    state: breakerState,
+    consecutiveFailures,
+    lastFailureAt: now,
+    cooldownUntil,
+    reasonCode: errorCode,
+    activeCount: existing?.activeCount ?? 0,
+    activeLimit: existing?.activeLimit ?? PROVIDER_ACTIVE_LIMIT
+  });
+  return breakerState === "open" && previousState !== "open";
+}
+function clearProviderBreaker(state, providerId, model) {
+  const key = makeBreakerKey(providerId, model);
+  const existing = state.entries.get(key);
+  const count = existing?.activeCount ?? 0;
+  if (count > 0) {
+    state.entries.set(key, {
+      providerId,
+      model,
+      state: "closed",
+      consecutiveFailures: 0,
+      lastFailureAt: 0,
+      cooldownUntil: 0,
+      reasonCode: "",
+      activeCount: count,
+      activeLimit: existing?.activeLimit ?? PROVIDER_ACTIVE_LIMIT
+    });
+  } else {
+    state.entries.delete(key);
+  }
+}
+function checkProviderCooldown(state, providerId, model) {
+  const key = makeBreakerKey(providerId, model);
+  const entry = state.entries.get(key);
+  if (!entry || entry.cooldownUntil === 0) {
+    return { blocked: false };
+  }
+  const now = Date.now();
+  if (now >= entry.cooldownUntil) {
+    entry.state = "half-open";
+    entry.cooldownUntil = 0;
+    entry.consecutiveFailures = 0;
+    state.entries.set(key, entry);
+    return { blocked: false };
+  }
+  return {
+    blocked: true,
+    remainingMs: entry.cooldownUntil - now,
+    reasonCode: entry.reasonCode,
+    entry
+  };
+}
+function formatCooldownMessage(providerId, model, remainingMs, language) {
+  const seconds = Math.ceil(remainingMs / 1e3);
+  if (language === "en-US") {
+    return [
+      `Model service ${providerId}/${model} is temporarily unstable and waiting before retry.`,
+      `Retry available in ~${seconds}s.`,
+      "You can run /model doctor to diagnose, or switch provider/model with /model."
+    ].join(" ");
+  }
+  return [
+    `\u6A21\u578B\u670D\u52A1 ${providerId}/${model} \u6682\u65F6\u4E0D\u7A33\u5B9A\uFF0C\u6B63\u5728\u7B49\u5F85\u6062\u590D\u3002`,
+    `\u7EA6 ${seconds} \u79D2\u540E\u53EF\u91CD\u8BD5\u3002`,
+    "\u53EF\u8FD0\u884C /model doctor \u8BCA\u65AD\uFF0C\u6216\u7528 /model \u5207\u6362\u670D\u52A1\u5546\u6216\u6A21\u578B\u3002"
+  ].join("");
+}
+function formatCooldownDoctorLine(state, language) {
+  const now = Date.now();
+  const active = [];
+  for (const entry of state.entries.values()) {
+    if (entry.cooldownUntil > now) {
+      const seconds = Math.ceil((entry.cooldownUntil - now) / 1e3);
+      active.push(
+        language === "en-US" ? `${entry.providerId}/${entry.model} waiting=${seconds}s reason=${entry.reasonCode}` : `${entry.providerId}/${entry.model} \u7B49\u5F85=${seconds}\u79D2 \u539F\u56E0=${entry.reasonCode}`
+      );
+    }
+  }
+  if (active.length === 0) {
+    return void 0;
+  }
+  const prefix = language === "en-US" ? "Active model-service cooldown" : "\u6A21\u578B\u670D\u52A1\u7B49\u5F85\u6062\u590D";
+  return `${prefix}: ${active.join("; ")}`;
+}
+var BREAKER_CONSTANTS = {
+  FAILURE_THRESHOLD: BREAKER_FAILURE_THRESHOLD,
+  COOLDOWN_MS: BREAKER_COOLDOWN_MS,
+  PROVIDER_ACTIVE_LIMIT,
+  RECOVERABLE_CODES
+};
+var RETRYABLE_KINDS = /* @__PURE__ */ new Set([
+  "gateway",
+  "transit",
+  "timeout",
+  "rate_limit"
+]);
+function shouldAttemptSameProviderRetry(kind) {
+  return RETRYABLE_KINDS.has(kind);
+}
+function getProviderErrorCode(error) {
+  if (error instanceof LinghunError) return error.code;
+  if (error instanceof Error && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  return "PROVIDER_ERROR";
+}
+var PROVIDER_RETRY_BASE_MS = 500;
+var PROVIDER_RETRY_MAX_MS = 32e3;
+var PROVIDER_RETRY_MAX_ATTEMPTS = 3;
+var PROVIDER_GATE_WAIT_MS_MIN = 1e3;
+var PROVIDER_GATE_WAIT_JITTER_MS = 2e3;
+function sleepAbortable(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        clearTimeout(timer);
+        resolve();
+      }, { once: true });
+    }
+  });
+}
+async function* withProviderRetry(gateway, state, provider, request, signal, opts) {
+  const maxRetries = opts?.maxRetries ?? PROVIDER_RETRY_MAX_ATTEMPTS;
+  const baseDelayMs = opts?.baseDelayMs ?? PROVIDER_RETRY_BASE_MS;
+  const maxDelayMs = opts?.maxDelayMs ?? PROVIDER_RETRY_MAX_MS;
+  const model = request.model ?? "";
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (signal?.aborted) {
+      yield {
+        type: "error",
+        error: new LinghunError({ code: "ABORT_ERR", message: "Request aborted.", recoverable: false })
+      };
+      return;
+    }
+    if (!opts?.skipGate) {
+      const gate = checkProviderGate(state, provider, model);
+      if (!gate.allowed) {
+        if (gate.reason === "at_capacity") {
+          await sleepAbortable(
+            PROVIDER_GATE_WAIT_MS_MIN + Math.random() * PROVIDER_GATE_WAIT_JITTER_MS,
+            signal
+          );
+          attempt -= 1;
+          continue;
+        }
+        if (gate.reason === "cooldown") {
+          yield {
+            type: "error",
+            error: new LinghunError({
+              code: gate.reasonCode,
+              message: `Provider ${provider}/${model} is in cooldown (${Math.ceil(gate.remainingMs / 1e3)}s remaining).`,
+              recoverable: true,
+              suggestion: "Wait for cooldown to expire, or switch provider/model with /model."
+            })
+          };
+          return;
+        }
+      }
+    }
+    const slotAcquired = acquireProviderSlot(state, provider, model);
+    if (!slotAcquired) {
+      await sleepAbortable(
+        PROVIDER_GATE_WAIT_MS_MIN + Math.random() * PROVIDER_GATE_WAIT_JITTER_MS,
+        signal
+      );
+      attempt -= 1;
+      continue;
+    }
+    let streamError;
+    let streamCompleted = false;
+    const pendingToolUses = [];
+    try {
+      for await (const event of gateway.stream(provider, request, signal ?? new AbortController().signal)) {
+        if (event.type === "error") {
+          streamError = event.error;
+          pendingToolUses.length = 0;
+          break;
+        }
+        if (event.type === "tool_use") {
+          pendingToolUses.push(event);
+          continue;
+        }
+        yield event;
+        if (event.type === "message_stop") {
+          streamCompleted = true;
+        }
+      }
+    } catch (error) {
+      streamError = error;
+      pendingToolUses.length = 0;
+    } finally {
+      releaseProviderSlot(state, provider, model);
+    }
+    if (!streamError && !streamCompleted) {
+      streamError = new LinghunError({
+        code: "PROVIDER_STREAM_ERROR",
+        message: `Provider ${provider}/${model} stream ended before message_stop.`,
+        recoverable: true
+      });
+    }
+    if (!streamError) {
+      clearProviderBreaker(state, provider, model);
+      for (const ev of pendingToolUses) yield ev;
+      return;
+    }
+    if (signal?.aborted) {
+      yield {
+        type: "error",
+        error: new LinghunError({ code: "ABORT_ERR", message: "Request aborted.", recoverable: false })
+      };
+      return;
+    }
+    const kind = classifyProviderFailure(streamError);
+    const code = getProviderErrorCode(streamError);
+    recordProviderFailure(state, provider, model, code);
+    if (!shouldAttemptSameProviderRetry(kind) || attempt >= maxRetries) {
+      const error = streamError instanceof LinghunError ? streamError : new LinghunError({
+        code,
+        message: streamError instanceof Error ? streamError.message : String(streamError),
+        recoverable: kind === "gateway" || kind === "transit" || kind === "timeout"
+      });
+      yield { type: "error", error };
+      return;
+    }
+    const baseDelay = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
+    const jitter = Math.random() * 0.25 * baseDelay;
+    const delayMs = baseDelay + jitter;
+    opts?.onRetry?.({
+      attempt: attempt + 1,
+      maxAttempts: maxRetries,
+      delayMs,
+      kind,
+      code
+    });
+    await sleepAbortable(delayMs, signal);
+  }
+}
+
+export {
+  createProviderCircuitBreakerState,
+  makeBreakerKey,
+  isRecoverableProviderFailure,
+  checkProviderGate,
+  acquireProviderSlot,
+  releaseProviderSlot,
+  recordProviderFailure,
+  clearProviderBreaker,
+  checkProviderCooldown,
+  formatCooldownMessage,
+  formatCooldownDoctorLine,
+  BREAKER_CONSTANTS,
+  withProviderRetry
+};