@wrongstack/core 0.310.1 → 0.313.1

package/dist/utils/sage-output-block.js

@@ -1,45 +1,8 @@
-// src/utils/sage-output-block.ts
-var SAGE_INJECTOR_HEADINGS = /* @__PURE__ */ new Set([
-  "--- SAGE: task-aware project knowledge (Memory Injector) ---",
-  "--- SAGE: related project knowledge (Memory Injector) ---"
-]);
-var SAGE_MEMORY_LINE = /^- \[[^\]]+\](?:\[[^\]]+\])* <memory id="[^"]+">.*<\/memory>(?: .*)?$/;
-var SAGE_MEMORY_LINE_TRUNCATED = /^- \[[^\]]+\](?:\[[^\]]+\])* <memory id="[^"]+">.*…$/;
-function splitSageOutputBlock(output) {
-  if (!output.includes("--- SAGE: ")) return { body: output, sageLines: [] };
-  const lines = output.split("\n");
-  for (let sageIdx = lines.length - 1; sageIdx >= 0; sageIdx--) {
-    if (!SAGE_INJECTOR_HEADINGS.has(lines[sageIdx] ?? "")) continue;
-    const candidate = lines.slice(sageIdx);
-    if (candidate.length < 2) continue;
-    const memoryLines = candidate.slice(1).filter((line) => line.trim().length > 0);
-    if (memoryLines.length === 0) continue;
-    const bodyOk = memoryLines.every(
-      (line, index) => SAGE_MEMORY_LINE.test(line) || index === memoryLines.length - 1 && SAGE_MEMORY_LINE_TRUNCATED.test(line)
-    );
-    if (!bodyOk) continue;
-    let end = candidate.length;
-    while (end > 1 && candidate[end - 1].trim().length === 0) end--;
-    return {
-      body: lines.slice(0, sageIdx).join("\n").trimEnd(),
-      sageLines: candidate.slice(0, end)
-    };
-  }
-  return { body: output, sageLines: [] };
-}
-function capSageLines(sageLines, maxChars) {
-  if (sageLines.length < 2) return [];
-  const header = sageLines[0];
-  if (header.length >= maxChars) return [];
-  const out = [header];
-  let used = header.length;
-  for (const line of sageLines.slice(1)) {
-    if (used + 1 + line.length > maxChars) break;
-    out.push(line);
-    used += 1 + line.length;
-  }
-  return out.length > 1 ? out : [];
-}
+import {
+  SAGE_INJECTOR_HEADINGS,
+  capSageLines,
+  splitSageOutputBlock
+} from "../chunk-SVT4RNTR.js";
 export {
   SAGE_INJECTOR_HEADINGS,
   capSageLines,

package/dist/wiring/proxy-rewrite.d.ts

@@ -8,8 +8,8 @@
  *
  * Example:
  *   original  = "https://api.openai.com/v1"
- *   proxyUrl  = "http://localhost:8000"
- *   output    = "http://localhost:8000/proxy/api.openai.com/v1"
+ *   proxyUrl  = "http://localhost:3444"
+ *   output    = "http://localhost:3444/proxy/api.openai.com/v1"
  *
  * The host appears *without* a scheme in the path; the proxy terminates
  * TLS (or speaks plain HTTP for localhost) and forwards the original
@@ -56,10 +56,25 @@ export interface ProxyConfig {
 }
 /** Read the current proxy configuration. Safe to call from any layer. */
 export declare function getProxyConfig(): ProxyConfig;
+/**
+ * Listener notified by `applyProxyConfig` when the resulting config
+ * MATERIALLY changed (`enabled` / `url` / `active`). The periodic probe
+ * re-writes the same healthy values every tick, so a value-identical
+ * write must NOT notify — subscribers (e.g. the instant-apply provider
+ * rebuilder) would otherwise run every probe interval.
+ */
+export type ProxyConfigListener = (next: ProxyConfig, previous: ProxyConfig) => void;
+/**
+ * Subscribe to material proxy-config changes. Returns an unsubscribe
+ * function. A throwing listener is isolated: it cannot break the probe
+ * loop or starve other subscribers.
+ */
+export declare function subscribeToProxyConfig(listener: ProxyConfigListener): () => void;
 /**
  * Apply a new proxy configuration. Returns the previous config so callers
  * (notably the probe) can decide whether the change requires an immediate
- * probe vs. waiting for the next tick.
+ * probe vs. waiting for the next tick. Notifies subscribers only when the
+ * merged result actually differs from the previous state.
  */
 export declare function applyProxyConfig(next: Partial<ProxyConfig>): ProxyConfig;
 /**
@@ -68,9 +83,82 @@ export declare function applyProxyConfig(next: Partial<ProxyConfig>): ProxyConfi
  * excluded" rule so future call sites can't accidentally skip a check.
  */
 export declare function shouldRewriteFor(providerId: string): boolean;
+/**
+ * Automatically deactivate the proxy if a connection failure occurs while
+ * the proxy was marked active. Triggers instant-apply provider rebuilds to
+ * fallback immediately to direct provider communication without failing the turn.
+ */
+export declare function deactivateProxyOnConnectionFailure(err: unknown): boolean;
 /**
  * Reset to defaults. Intended for tests; do NOT call from production code
- * (the singleton lives for the lifetime of the process).
+ * (the singleton lives for the lifetime of the process). Also drops all
+ * change listeners so tests never observe each other's notifications.
  */
 export declare function __resetProxyConfigForTests(): void;
+/** Upper bound for {@link waitForProxyRoutingSettle}. Local provider builds
+ *  settle in single-digit milliseconds; anything slower means the host is
+ *  doing network work inside rebuildProvider, and a retrying turn must not
+ *  hang on it. Resolves on timeout — the barrier delays, never fails. */
+export declare const PROXY_ROUTING_SETTLE_CAP_MS = 2000;
+/**
+ * Wait until every registered instant-apply rebuild triggered by the current
+ * proxy-config change has settled, the cap elapses, or `signal` aborts.
+ * Resolves in all three cases — a settle timeout must not fail the turn,
+ * only stop delaying it.
+ */
+export declare function waitForProxyRoutingSettle(timeoutMs?: number, signal?: AbortSignal | undefined): Promise<void>;
+/** Minimal structural logger — keeps this module dependency-free. */
+export interface ProxyInstantApplyLogger {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+}
+export interface ProxyInstantApplyDeps {
+    /** Current active provider id — the provider whose URL is baked in. */
+    getActiveProviderId: () => string;
+    /**
+     * Raw (pre-rewrite) base URL for a provider id, exactly as
+     * `resolveProviderCfg` reads it: `savedCfg?.baseUrl ?? config.baseUrl`.
+     * The singleton holds no provider configs, so the caller — who owns the
+     * live Config — must inject this reader.
+     */
+    getRawBaseUrl: (providerId: string) => string | undefined;
+    /**
+     * Rebuild the live provider for `providerId` and swap it into the live
+     * context. Callers inject their existing path — e.g.
+     * `buildProviderForModel(providerId, model)` — which re-resolves
+     * proxy-aware config via `shouldRewriteFor` on every build. Should
+     * serialize the swap through the host's model-transition gate and
+     * re-check the live provider id inside it (superseded guard).
+     */
+    rebuildProvider: (providerId: string) => Promise<void>;
+    /** Structured logger for the rebuild decisions. */
+    logger: ProxyInstantApplyLogger;
+}
+export interface ProxyInstantApplyHandle {
+    /** Detach the subscription. Safe to call more than once. */
+    dispose: () => void;
+}
+/**
+ * Subscribe to material proxy-config changes and rebuild the live
+ * provider when the routing verdict for the ACTIVE provider changes.
+ *
+ * Comparison is on the effective base URL, so:
+ *   - probe ticks that rewrite identical values never rebuild;
+ *   - a proxy URL change while enabled+active rebuilds (new target);
+ *   - deactivation rebuilds (proxy-rewritten → raw);
+ *   - toggling off while already direct does NOT rebuild;
+ *   - a provider/model switch between notifications re-baselines against
+ *     the PREVIOUS config — the config the switch actually built under —
+ *     and then falls through to the verdict comparison. Seeding from the
+ *     new config instead would swallow a needed rebuild: a provider that
+ *     switched in while the proxy was on (built rewritten) must rebuild
+ *     direct when the very next change deactivates the proxy.
+ *
+ * Rebuilds are SERIALIZED: a toggle-off immediately followed by a probe
+ * verdict must not race two async rebuilds against each other — the
+ * slower, stale build could overwrite the fresh provider swap. Each
+ * rebuild re-reads proxy state at build time, so the chain converges on
+ * the latest verdict.
+ */
+export declare function createProxyInstantApply(deps: ProxyInstantApplyDeps): ProxyInstantApplyHandle;
 //# sourceMappingURL=proxy-rewrite.d.ts.map

package/dist/wiring/proxy-rewrite.js

@@ -1,70 +1,29 @@
-// src/wiring/proxy-rewrite.ts
-var PROXY_PATH_PREFIX = "/proxy/";
-var PROXY_EXCLUDED_PROVIDERS = /* @__PURE__ */ new Set(["openai-codex"]);
-function isProxyEligible(providerId) {
-  if (!providerId) return false;
-  if (PROXY_EXCLUDED_PROVIDERS.has(providerId)) return false;
-  return true;
-}
-function rewriteBaseUrl(originalBaseUrl, proxyUrl) {
-  if (!originalBaseUrl) return void 0;
-  if (!proxyUrl) return originalBaseUrl;
-  if (!isProxyEligibleForRewrite(originalBaseUrl, proxyUrl)) return originalBaseUrl;
-  return composeRewrittenUrl(originalBaseUrl, proxyUrl);
-}
-function isProxyEligibleForRewrite(originalBaseUrl, proxyUrl) {
-  if (!originalBaseUrl.includes("://")) return false;
-  if (!proxyUrl.includes("://")) return false;
-  const normalizedProxy = proxyUrl.replace(/\/+$/, "");
-  if (originalBaseUrl.startsWith(`${normalizedProxy}${PROXY_PATH_PREFIX}`)) {
-    return false;
-  }
-  try {
-    const parsed = new URL(originalBaseUrl);
-    const isLoopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || // WHATWG URL serializes IPv6 hosts with brackets — `[::1]`, not `::1`.
-    parsed.hostname === "[::1]";
-    if (isLoopback && parsed.port !== "") return false;
-  } catch {
-  }
-  return true;
-}
-function composeRewrittenUrl(originalBaseUrl, proxyUrl) {
-  const parsedOriginal = new URL(originalBaseUrl);
-  const hostAndPath = `${parsedOriginal.host}${parsedOriginal.pathname}`;
-  const trailingQuery = parsedOriginal.search || "";
-  const trailingHash = parsedOriginal.hash || "";
-  const proxyRoot = proxyUrl.replace(/\/+$/, "");
-  return `${proxyRoot}${PROXY_PATH_PREFIX}${hostAndPath}${trailingQuery}${trailingHash}`;
-}
-var DEFAULT_PROXY_CONFIG = { enabled: false, url: "", active: false };
-var currentConfig = { ...DEFAULT_PROXY_CONFIG };
-function getProxyConfig() {
-  return currentConfig;
-}
-function applyProxyConfig(next) {
-  const previous = currentConfig;
-  currentConfig = {
-    enabled: next.enabled ?? previous.enabled,
-    url: next.url ?? previous.url,
-    active: next.active ?? previous.active
-  };
-  return previous;
-}
-function shouldRewriteFor(providerId) {
-  const cfg = currentConfig;
-  if (!cfg.enabled || !cfg.active || !cfg.url) return false;
-  return isProxyEligible(providerId);
-}
-function __resetProxyConfigForTests() {
-  currentConfig = { ...DEFAULT_PROXY_CONFIG };
-}
+import {
+  PROXY_EXCLUDED_PROVIDERS,
+  PROXY_ROUTING_SETTLE_CAP_MS,
+  __resetProxyConfigForTests,
+  applyProxyConfig,
+  createProxyInstantApply,
+  deactivateProxyOnConnectionFailure,
+  getProxyConfig,
+  isProxyEligible,
+  rewriteBaseUrl,
+  shouldRewriteFor,
+  subscribeToProxyConfig,
+  waitForProxyRoutingSettle
+} from "../chunk-4ZHTKJHM.js";
 export {
   PROXY_EXCLUDED_PROVIDERS,
+  PROXY_ROUTING_SETTLE_CAP_MS,
   __resetProxyConfigForTests,
   applyProxyConfig,
+  createProxyInstantApply,
+  deactivateProxyOnConnectionFailure,
   getProxyConfig,
   isProxyEligible,
   rewriteBaseUrl,
-  shouldRewriteFor
+  shouldRewriteFor,
+  subscribeToProxyConfig,
+  waitForProxyRoutingSettle
 };
 //# sourceMappingURL=proxy-rewrite.js.map