@remnic/core 10.0.74 → 10.0.75

package/src/local-llm-json-schema-fallback.test.ts

@@ -1,9 +1,14 @@
 import assert from "node:assert/strict";
+import fs from "node:fs";
 import http from "node:http";
+import os from "node:os";
 import type { AddressInfo } from "node:net";
+import { join } from "node:path";
 import test, { mock } from "node:test";
 
 import { LocalLlmClient } from "./local-llm.js";
+import { ModelRegistry } from "./model-registry.js";
+import { NativeSchemaGate, type LocalLlmChatRequestBody } from "./local-llm-native-schema.js";
 import { ChatTransport } from "./local-llm-transport.js";
 import { parseConfig } from "./config.js";
 import type { LocalLlmChatCompletionOptions } from "./local-llm-helpers.js";
@@ -276,3 +281,313 @@ test("request without response_format is unchanged", async () => {
   }
 });
 
+// ── Schema-validation rejections (the provider parses our json_schema) ──────
+//
+// Production signature (2026-11-05, MiniMax-M3.1-Flash via local proxy): a
+// 400 "invalid params — Mismatch type string with value array" quoting a
+// schema fragment like `"episodeTitle": {"type": ["string","null"]}`. The
+// provider accepts structured output in principle but its strict parser
+// rejects our draft-7 nullable type unions. Unlike capability rejections
+// these errors never name response_format, so nothing stripped the format,
+// every drain attempt re-sent the identical payload, and the 400 breaker
+// opened. The zod draft-7 schema legitimately contains `type` arrays
+// (nullable fields), so the provider dialect, not our request, is the
+// constraint: degrade to the pre-schema request shape and remember it.
+
+const schemaValidationRejection = {
+  error: {
+    // Verbatim production body shape (2026-11-05): "Mismatch type" (no "ed"),
+    // JSON-escaped quotes around the schema fragment, and no mention of
+    // response_format anywhere.
+    message:
+      'invalid params, Mismatch type string with value array "at index 13779: \\"episodeTitle\\": {\\"type\\": [\\"string\\",\\"null\\"]}"',
+  },
+};
+
+test("a schema-validation 400 strips the format and retries without it", async () => {
+  const server = await startRecordingServer((_req, count) =>
+    count === 1
+      ? { status: 400, body: schemaValidationRejection }
+      : { status: 200, body: okCompletion },
+  );
+  try {
+    const client = new LocalLlmClient(createConfig({ localLlmUrl: server.url }));
+    primeClient(client);
+    const result = await client.chatCompletion([{ role: "user", content: "hello" }], {
+      responseFormat,
+    });
+    assert.equal(result?.content, "done");
+    assert.equal(server.requests.length, 2, "exactly one strip-and-retry");
+    assert.ok(server.requests[0].body.response_format, "the schema-shaped request went out first");
+    assert.equal(server.requests[1].body.response_format, undefined);
+  } finally {
+    await server.close();
+  }
+});
+
+test("a rejected schema format is not re-sent on later requests", async () => {
+  const server = await startRecordingServer((_req, count) =>
+    count === 1
+      ? { status: 400, body: schemaValidationRejection }
+      : { status: 200, body: okCompletion },
+  );
+  try {
+    const client = new LocalLlmClient(createConfig({ localLlmUrl: server.url }));
+    primeClient(client);
+    assert.equal(
+      (await client.chatCompletion([{ role: "user", content: "hello" }], { responseFormat }))?.content,
+      "done",
+    );
+    assert.equal(
+      (await client.chatCompletion([{ role: "user", content: "hello again" }], { responseFormat }))?.content,
+      "done",
+    );
+    assert.equal(server.requests.length, 3, "second call sends one request, not a new 400");
+    assert.equal(
+      server.requests[2].body.response_format,
+      undefined,
+      "the learned rejection skips the format entirely",
+    );
+  } finally {
+    await server.close();
+  }
+});
+
+test("a learned schema rejection persists in the model registry for fresh clients", async () => {
+  const memoryDir = fs.mkdtempSync(join(os.tmpdir(), "remnic-schema-cap-"));
+  const server = await startRecordingServer((_req, count) =>
+    count === 1
+      ? { status: 400, body: schemaValidationRejection }
+      : { status: 200, body: okCompletion },
+  );
+  try {
+    const registry = new ModelRegistry(memoryDir);
+    const client = new LocalLlmClient(createConfig({ localLlmUrl: server.url }), registry);
+    primeClient(client);
+    assert.equal(
+      (await client.chatCompletion([{ role: "user", content: "hello" }], { responseFormat }))?.content,
+      "done",
+    );
+    // SAFETY: we wrote model-capabilities.json through ModelRegistry above; the
+    // document is an object keyed by normalized model id.
+    const persisted = JSON.parse(
+      fs.readFileSync(join(memoryDir, ".registry", "model-capabilities.json"), "utf8"),
+    ) as { models: Record<string, { structuredOutput?: string }> };
+    assert.equal(persisted.models["test-local-model"]?.structuredOutput, "none");
+
+    const fresh = new LocalLlmClient(createConfig({ localLlmUrl: server.url }), new ModelRegistry(memoryDir));
+    primeClient(fresh);
+    assert.equal(
+      (await fresh.chatCompletion([{ role: "user", content: "hello" }], { responseFormat }))?.content,
+      "done",
+    );
+    const formatRequests = server.requests.filter((r) => r.body.response_format);
+    assert.equal(formatRequests.length, 1, "only the first-ever request carries the format");
+  } finally {
+    await server.close();
+    fs.rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a schema-carrying success records native and keeps sending the format", async () => {
+  const memoryDir = fs.mkdtempSync(join(os.tmpdir(), "remnic-schema-cap-"));
+  const server = await startRecordingServer(() => ({ status: 200, body: okCompletion }));
+  try {
+    const registry = new ModelRegistry(memoryDir);
+    const client = new LocalLlmClient(createConfig({ localLlmUrl: server.url }), registry);
+    primeClient(client);
+    await client.chatCompletion([{ role: "user", content: "hello" }], { responseFormat });
+    await client.chatCompletion([{ role: "user", content: "hello again" }], { responseFormat });
+    // SAFETY: we wrote model-capabilities.json through ModelRegistry above; the
+    // document is an object keyed by normalized model id.
+    const persisted = JSON.parse(
+      fs.readFileSync(join(memoryDir, ".registry", "model-capabilities.json"), "utf8"),
+    ) as { models: Record<string, { structuredOutput?: string }> };
+    assert.equal(persisted.models["test-local-model"]?.structuredOutput, "native");
+    assert.equal(server.requests.length, 2);
+    assert.ok(server.requests[1].body.response_format, "structured output remains for supporting providers");
+  } finally {
+    await server.close();
+    fs.rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("an expired registry rejection is re-probed instead of honored forever", async () => {
+  const memoryDir = fs.mkdtempSync(join(os.tmpdir(), "remnic-schema-cap-"));
+  const server = await startRecordingServer(() => ({ status: 200, body: okCompletion }));
+  try {
+    const registry = new ModelRegistry(memoryDir);
+    registry.setStructuredOutput("test-local-model", "none");
+    // Age the entry past the 7-day registry TTL, as a long-lived deployment
+    // would: the learned rejection must not be honored forever.
+    const registryPath = join(memoryDir, ".registry", "model-capabilities.json");
+    // SAFETY: we wrote model-capabilities.json through ModelRegistry above; the
+    // document is an object keyed by normalized model id.
+    const persisted = JSON.parse(fs.readFileSync(registryPath, "utf8")) as {
+      models: Record<string, { fetchedAt: string }>;
+    };
+    persisted.models["test-local-model"].fetchedAt = new Date(
+      Date.now() - 8 * 24 * 60 * 60 * 1000,
+    ).toISOString();
+    fs.writeFileSync(registryPath, JSON.stringify(persisted));
+
+    const client = new LocalLlmClient(createConfig({ localLlmUrl: server.url }), new ModelRegistry(memoryDir));
+    primeClient(client);
+    const result = await client.chatCompletion([{ role: "user", content: "hello" }], {
+      responseFormat,
+    });
+    assert.equal(result?.content, "done");
+    assert.ok(server.requests[0].body.response_format, "expired rejection is re-probed with the schema");
+    // The provider accepts it this time: the native record refreshes.
+    // SAFETY: the file above was written by ModelRegistry's own persistence;
+    // the document is an object keyed by normalized model id.
+    const refreshed = JSON.parse(fs.readFileSync(registryPath, "utf8")) as {
+      models: Record<string, { structuredOutput?: string }>;
+    };
+    assert.equal(refreshed.models["test-local-model"]?.structuredOutput, "native");
+  } finally {
+    await server.close();
+    fs.rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a later capabilities write preserves the learned structuredOutput", async () => {
+  const memoryDir = fs.mkdtempSync(join(os.tmpdir(), "remnic-schema-cap-"));
+  try {
+    const registry = new ModelRegistry(memoryDir);
+    registry.setStructuredOutput("test-local-model", "none");
+    // Mirrors getCachedContextWindow's LM Studio detection replacing the record.
+    registry.setCapabilities("test-local-model", {
+      maxPositionEmbeddings: 131072,
+      contextWindow: 131072,
+      supportsExtendedContext: true,
+      typicalOutputTokens: 8192,
+      source: "lmstudio",
+    });
+    assert.equal(registry.getStructuredOutput("test-local-model"), "none");
+  } finally {
+    fs.rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("an expired structuredOutput decision is not renewed by a capability refresh", async () => {
+  const memoryDir = fs.mkdtempSync(join(os.tmpdir(), "remnic-schema-cap-"));
+  try {
+    const registry = new ModelRegistry(memoryDir);
+    registry.setStructuredOutput("test-local-model", "none");
+    // Age the learned decision past the registry TTL exactly as a long-lived
+    // deployment would.
+    const registryPath = join(memoryDir, ".registry", "model-capabilities.json");
+    // SAFETY: we wrote model-capabilities.json through ModelRegistry above; the
+    // document is an object keyed by normalized model id.
+    const persisted = JSON.parse(fs.readFileSync(registryPath, "utf8")) as {
+      models: Record<string, { fetchedAt: string }>;
+    };
+    persisted.models["test-local-model"].fetchedAt = new Date(
+      Date.now() - 8 * 24 * 60 * 60 * 1000,
+    ).toISOString();
+    fs.writeFileSync(registryPath, JSON.stringify(persisted));
+    // The refresh happens in a process that loaded the AGED state from disk
+    // (a restart or another runtime sharing the memory dir).
+    const refreshedRegistry = new ModelRegistry(memoryDir);
+    refreshedRegistry.setCapabilities("test-local-model", {
+      maxPositionEmbeddings: 131072,
+      contextWindow: 131072,
+      supportsExtendedContext: true,
+      typicalOutputTokens: 8192,
+      source: "lmstudio",
+    });
+    assert.equal(
+      refreshedRegistry.getStructuredOutput("test-local-model"),
+      undefined,
+      "an expired decision must not be renewed into a fresh record — the re-probe stays due",
+    );
+  } finally {
+    fs.rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a stale in-flight schema success does not overwrite a current rejection", () => {
+  const memoryDir = fs.mkdtempSync(join(os.tmpdir(), "remnic-schema-cap-"));
+  try {
+    const registry = new ModelRegistry(memoryDir);
+    const gate = new NativeSchemaGate(() => registry);
+    // Two schema-bearing requests attach before either settles.
+    const body: LocalLlmChatRequestBody = {
+      model: "test-local-model",
+      messages: [{ role: "user", content: "hello" }],
+      temperature: 0.1,
+      max_tokens: 16,
+      stream: false,
+    };
+    gate.attach(body, { responseFormat }, "test-local-model");
+    // The rejection settles first: "none" is the newest evidence.
+    gate.rememberRejection("test-local-model");
+    // The older in-flight success settles last: it must not flip the
+    // decision back, or later requests re-send the rejected schema.
+    gate.recordSuccess(body, "test-local-model");
+    assert.equal(registry.getStructuredOutput("test-local-model"), "none");
+    // A fresh success with no rejection standing still records native.
+    const otherBody: LocalLlmChatRequestBody = { ...body, model: "other-model" };
+    const freshGate = new NativeSchemaGate(() => registry);
+    freshGate.attach(otherBody, { responseFormat }, "other-model");
+    freshGate.recordSuccess(otherBody, "other-model");
+    assert.equal(registry.getStructuredOutput("other-model"), "native");
+  } finally {
+    fs.rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("invalid params without schema evidence is not treated as a schema rejection", async () => {
+  const server = await startRecordingServer(() => ({
+    status: 400,
+    body: { error: { message: "invalid params: temperature must be between 0 and 2" } },
+  }));
+  try {
+    const client = new LocalLlmClient(createConfig({ localLlmUrl: server.url }));
+    primeClient(client);
+    assert.equal(await client.chatCompletion([{ role: "user", content: "hello" }], { responseFormat }), null);
+    assert.equal(server.requests.length, 1, "unrelated invalid-param errors must not strip the format");
+  } finally {
+    await server.close();
+  }
+});
+
+test("an echoed format name inside an unrelated invalid-param error does not strip", async () => {
+  const server = await startRecordingServer(() => ({
+    status: 400,
+    body: {
+      error: {
+        message: "invalid params: quota exceeded; request included response_format json_schema",
+      },
+    },
+  }));
+  try {
+    const client = new LocalLlmClient(createConfig({ localLlmUrl: server.url }));
+    primeClient(client);
+    assert.equal(await client.chatCompletion([{ role: "user", content: "hello" }], { responseFormat }), null);
+    assert.equal(server.requests.length, 1, "an echo of the format name is not schema-rejection evidence");
+  } finally {
+    await server.close();
+  }
+});
+
+test("a type mismatch on an unrelated parameter does not strip the schema", async () => {
+  const server = await startRecordingServer(() => ({
+    status: 400,
+    body: { error: { message: "invalid params: mismatch type for temperature, expected number" } },
+  }));
+  try {
+    const client = new LocalLlmClient(createConfig({ localLlmUrl: server.url }));
+    primeClient(client);
+    assert.equal(await client.chatCompletion([{ role: "user", content: "hello" }], { responseFormat }), null);
+    assert.equal(
+      server.requests.length,
+      1,
+      "no schema fragment quoted: the mismatch is not evidence our schema was rejected",
+    );
+  } finally {
+    await server.close();
+  }
+});
+

package/src/local-llm-native-schema.ts

@@ -0,0 +1,78 @@
+/**
+ * Native json_schema capability shaping for the local LLM client.
+ *
+ * A provider that rejects the schema PAYLOAD itself (strict parsers that die
+ * on draft-7 nullable `type` unions, e.g. MiniMax-M3.1-Flash on 2026-11-05:
+ * "invalid params, Mismatch type string with value array") gets the pre-#3248
+ * shape: no response_format, the JSON contract stays in the prompt. The
+ * rejection is learned per model and persisted through the ModelRegistry so
+ * fresh runtimes shape requests correctly without re-proving it; a
+ * schema-carrying success persists `structuredOutput: "native"`.
+ */
+
+import type { ResponseFormatJSONSchema } from "openai/resources/shared";
+import type { LocalLlmChatCompletionOptions } from "./local-llm-helpers.js";
+import type { ModelRegistry } from "./model-registry.js";
+
+/** The chat-completions wire body; optional keys are capability-gated additions. */
+export interface LocalLlmChatRequestBody {
+  model: string;
+  messages: Array<{ role: string; content: string }>;
+  temperature: number;
+  max_tokens: number;
+  stream: boolean;
+  response_format?: { type: string } | ResponseFormatJSONSchema;
+  chat_template_kwargs?: { enable_thinking: boolean };
+  reasoning_effort?: string;
+}
+
+/** Learned structured-output shaping for one local endpoint. */
+export class NativeSchemaGate {
+  /** Models rejected in this process — the fallback for registry-less clients. */
+  private readonly rejectedByProcess = new Set<string>();
+
+  constructor(private readonly registry: () => ModelRegistry | undefined) {}
+
+  /** False when the model is known to reject the native json_schema payload. */
+  usable(modelId: string): boolean {
+    const registry = this.registry();
+    // Registry-backed decisions honor the registry TTL: an expired entry is
+    // re-probed instead of being honored forever. The in-memory set only
+    // serves clients without a registry.
+    if (registry) return registry.getStructuredOutput(modelId) !== "none";
+    return !this.rejectedByProcess.has(modelId);
+  }
+
+  rememberRejection(modelId: string): void {
+    const registry = this.registry();
+    if (registry) registry.setStructuredOutput(modelId, "none");
+    else this.rejectedByProcess.add(modelId);
+  }
+
+  /** Attach the schema format unless the gate suppresses it for this model. */
+  attach(
+    requestBody: LocalLlmChatRequestBody,
+    options: Pick<LocalLlmChatCompletionOptions, "responseFormat">,
+    modelId: string,
+  ): void {
+    if (options.responseFormat?.type === "json_schema" && this.usable(modelId)) {
+      requestBody.response_format = options.responseFormat;
+    }
+  }
+
+  /** A schema-carrying 200: persist the native capability once. A CURRENT
+   *  "none" stands — that success is stale in-flight evidence from before the
+   *  rejection, and overwriting it would make later requests re-send the
+   *  rejected schema. */
+  recordSuccess(requestBody: LocalLlmChatRequestBody, modelId: string): void {
+    const registry = this.registry();
+    if (
+      !requestBody.response_format ||
+      !registry ||
+      registry.getStructuredOutput(modelId) !== undefined
+    ) {
+      return;
+    }
+    registry.setStructuredOutput(modelId, "native");
+  }
+}

package/src/local-llm.ts

@@ -24,6 +24,7 @@ import {
   type LocalLlmChatCompletionOptions,
   type LocalLlmChatCompletionResult,
 } from "./local-llm-helpers.js";
+import { NativeSchemaGate, type LocalLlmChatRequestBody } from "./local-llm-native-schema.js";
 import {
   isObjectRecord,
   orderedLocalServers,
@@ -189,6 +190,7 @@ export class LocalLlmClient {
   private consecutive400s: number = 0;
   private cooldownUntilMs: number = 0;
   private modelRegistry?: ModelRegistry;
+  private readonly nativeSchemaGate = new NativeSchemaGate(() => this.modelRegistry);
   private _disableThinking: boolean = false;
   private readonly requestQueues: Record<LocalLlmRequestPriority, LocalLlmQueuedRequest[]> = {
     "recall-critical": [],
@@ -887,21 +889,16 @@ export class LocalLlmClient {
       }
 
       const promptChars = messages.reduce((sum, m) => sum + (m.content?.length ?? 0), 0);
-      const requestBody: Record<string, unknown> = {
-        model: options.model ?? this.config.localLlmModel,
+      const requestModel = options.model ?? this.config.localLlmModel;
+      const requestBody: LocalLlmChatRequestBody = {
+        model: requestModel,
         messages,
         temperature: options.temperature ?? 0.7,
         // Use max_tokens consistent with cloud models
         max_tokens: options.maxTokens ?? 4096,
         stream: false,
       };
-
-      // Skip response_format for local LLMs - they don't support json_object type
-      // The prompts already instruct the model to output JSON
-      // Only send if it's json_schema type which some local LLMs support
-      if (options.responseFormat?.type === "json_schema") {
-        requestBody.response_format = options.responseFormat;
-      }
+      this.nativeSchemaGate.attach(requestBody, options, requestModel);
 
       // Suppress thinking/reasoning for operations that benefit from terse,
       // structured output. Thinking-capable models (Qwen 3.5, Gemma 4,
@@ -1016,6 +1013,7 @@ export class LocalLlmClient {
             requestBody.response_format &&
             isUnsupportedJsonSchemaError(`400 ${responseBody}`)
           ) {
+            this.nativeSchemaGate.rememberRejection(requestModel);
             // Match gateway degradation without extending this attempt's deadline.
             delete requestBody.response_format;
             requestBodyJson = JSON.stringify(requestBody);
@@ -1150,6 +1148,7 @@ export class LocalLlmClient {
         return null;
       }
       this.consecutive400s = 0;
+      this.nativeSchemaGate.recordSuccess(requestBody, requestModel);
 
       const data = JSON.parse(responseBody) as {
         choices?: Array<{

package/src/model-registry.ts

@@ -19,6 +19,8 @@ export interface ModelCapabilities {
   };
   typicalOutputTokens: number;
   source: "huggingface" | "lmstudio" | "manual" | "default";
+  /** Learned structured-output shaping (see ModelRegistry.getStructuredOutput). */
+  structuredOutput?: "native" | "none";
   fetchedAt: string;
 }
 
@@ -193,6 +195,9 @@ export class ModelRegistry {
           ...capabilities,
           modelId: normalizedId,
           source: "default",
+          // Reachable only with a missing or expired cached record, so any
+          // learned structuredOutput is stale here — leave it unset and let
+          // getStructuredOutput's freshness rules drive the re-probe.
           fetchedAt: new Date().toISOString(),
         };
         this.data.models[normalizedId] = caps;
@@ -214,8 +219,15 @@ export class ModelRegistry {
    */
   setCapabilities(modelId: string, capabilities: Omit<ModelCapabilities, "modelId" | "fetchedAt">): void {
     const normalizedId = this.normalizeModelId(modelId);
+    const previous = this.data.models[normalizedId];
     const caps: ModelCapabilities = {
       ...capabilities,
+      // A replacement record (e.g. fresh LM Studio detection) must not erase a
+      // learned structuredOutput shaping — but an EXPIRED decision must not be
+      // renewed either: drop it so the re-probe stays due.
+      structuredOutput:
+        capabilities.structuredOutput ??
+        (previous && !this.isCacheExpired(previous) ? previous.structuredOutput : undefined),
       modelId: normalizedId,
       fetchedAt: new Date().toISOString(),
     };
@@ -224,6 +236,34 @@ export class ModelRegistry {
     log.info(`ModelRegistry: stored capabilities for ${modelId}`);
   }
 
+  /**
+   * Learned structured-output shaping for a model, persisted so fresh
+   * runtimes shape requests correctly without re-proving a rejection.
+   * Honors the cache TTL: a provider that later gains schema support is
+   * re-probed (one degraded request) after the window lapses.
+   */
+  getStructuredOutput(modelId: string): "native" | "none" | undefined {
+    const cached = this.data.models[this.normalizeModelId(modelId)];
+    if (!cached || this.isCacheExpired(cached)) return undefined;
+    return cached.structuredOutput;
+  }
+
+  /** Merge-and-persist: preserves any previously learned capabilities. */
+  setStructuredOutput(modelId: string, mode: "native" | "none"): void {
+    const normalizedId = this.normalizeModelId(modelId);
+    const base = this.data.models[normalizedId] ?? {
+      ...DEFAULT_CAPABILITIES,
+      modelId: normalizedId,
+    };
+    this.data.models[normalizedId] = {
+      ...base,
+      structuredOutput: mode,
+      fetchedAt: new Date().toISOString(),
+    };
+    this.saveRegistry();
+    log.info(`ModelRegistry: stored structuredOutput=${mode} for ${modelId}`);
+  }
+
   /**
    * Calculate optimal input/output sizes for a model
    * @param maxContextOverride - Optional override for max context (e.g., if LLM server defaults to smaller window)

package/src/orchestration/backlog-scheduler.ts

@@ -32,6 +32,7 @@ import type { BufferDrainClaims, DrainLease } from "../storage/buffer-drain-clai
 import { BufferDrainRunner } from "./buffer-drain-runner.js";
 import type { DrainRunnerEvent, DrainSessionOutcome } from "./buffer-drain-runner.js";
 import type { ExtractionQueueCoordinator } from "./extraction-queue-coordinator.js";
+import type { ProviderBreakerSnapshot } from "./provider-breaker.js";
 
 /** What the scheduler needs from its host (structurally satisfied by the
  *  orchestrator wiring); injectable so tests drive ticks deterministically. */
@@ -50,6 +51,13 @@ export interface BacklogSchedulerDeps {
     key: string,
     options: { ownerId: string; signal: AbortSignal; onEvent?: (event: DrainRunnerEvent) => void }
   ): Promise<DrainSessionOutcome>;
+  /** Shared provider circuit-breaker snapshot (the same instance the run
+   *  coordinator gates attempts on). While OPEN inside its cooldown window
+   *  the scheduler skips submission entirely — claims stay durable, and the
+   *  breaker's single half-open probe (one attempt through once the window
+   *  lapses) keeps recovery automatic. Optional: hosts without a breaker
+   *  never skip. */
+  breakerSnapshot?(): ProviderBreakerSnapshot;
   /** Test seam: monotonic-ish clock for backoff windows. */
   now?(): number;
 }
@@ -211,6 +219,18 @@ export class BacklogScheduler {
     this.ticking = true;
     const cursorBeforeTick = this.claimCursor;
     try {
+      // Fast bail: a breaker already open must not pay discovery I/O
+      // (listPage reads and parses claim bodies on every poll). The
+      // submitCandidates guard below still catches a breaker that opens
+      // while discovery awaits.
+      const breakerBeforeDiscovery = this.deps.breakerSnapshot?.();
+      if (
+        breakerBeforeDiscovery &&
+        breakerBeforeDiscovery.state === "open" &&
+        this.now() < breakerBeforeDiscovery.openUntilMs
+      ) {
+        return;
+      }
       // stop() may land while discovery's I/O is pending: re-check before
       // submitting anything, and again per candidate.
       // A discovery failure (EACCES/EIO on the claims dir) must not reject
@@ -269,6 +289,15 @@ export class BacklogScheduler {
 
   /** Submit discovery candidates within the queue's concurrency bound. */
   private submitCandidates(candidates: { key: string; needsClaim: boolean }[]): boolean {
+    // Breaker-open churn guard: a full attempt reads the claim, rebuilds the
+    // buffer/coordinator and re-renders chunks before the breaker fails it
+    // fast — pure heap pressure per poll during a provider stall. Skip while
+    // the window is open; once it lapses, submissions resume and the
+    // breaker's half-open probe runs as usual.
+    const breaker = this.deps.breakerSnapshot?.();
+    if (breaker && breaker.state === "open" && this.now() < breaker.openUntilMs) {
+      return true;
+    }
     let dropped = false;
     for (const candidate of candidates) {
       if (this.stopped || this.inFlight.size >= this.submissionLimit()) {
@@ -475,6 +504,9 @@ export function wireBacklogScheduler(
         };
       },
       drainKey: (key, drainOptions) => runner.drainSession(key, drainOptions),
+      // The orchestrator's one shared provider breaker (foreground and every
+      // claim-backed drain accumulate toward the same threshold).
+      breakerSnapshot: () => orchestrator.getExtractionResilienceStatus().breaker,
     },
     { ...options, ownerId }
   );

package/dist/chunk-5MA7ZLPD.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/model-registry.ts"],"sourcesContent":["/**\n * Model Registry - Stores and retrieves model capabilities\n * Avoids repeated external lookups by caching model info locally\n */\n\nimport { log } from \"./logger.js\";\nimport fs from \"node:fs\";\nimport { dirname, join } from \"node:path\";\n\nexport interface ModelCapabilities {\n  modelId: string;\n  maxPositionEmbeddings: number;\n  contextWindow: number;\n  supportsExtendedContext: boolean;\n  ropeScaling?: {\n    type: string;\n    factor: number;\n    originalMaxPositionEmbeddings: number;\n  };\n  typicalOutputTokens: number;\n  source: \"huggingface\" | \"lmstudio\" | \"manual\" | \"default\";\n  fetchedAt: string;\n}\n\ninterface ModelRegistryData {\n  models: Record<string, ModelCapabilities>;\n  version: number;\n}\n\nconst DEFAULT_CAPABILITIES: ModelCapabilities = {\n  modelId: \"default\",\n  maxPositionEmbeddings: 32768,\n  contextWindow: 32768,\n  supportsExtendedContext: false,\n  typicalOutputTokens: 8192,\n  source: \"default\",\n  fetchedAt: new Date().toISOString(),\n};\n\n// Known model capabilities (fallback when offline)\n// NOTE: Context windows here are the MODEL's theoretical maximum. Local LLM servers\n// (LM Studio, Ollama, etc.) often load models with smaller default context windows.\n// If you get \"context length exceeded\" errors, either:\n// 1. Increase the context window in your LLM server UI (recommended)\n// 2. Set localLlmMaxContext in openclaw.json to limit prompts (fallback)\nconst KNOWN_MODELS: Record<string, Partial<ModelCapabilities>> = {\n  \"qwen3-30b-a3b-instruct\": {\n    maxPositionEmbeddings: 40960,\n    contextWindow: 131072, // 128K with YaRN - but LM Studio defaults to ~32K\n    supportsExtendedContext: true,\n    ropeScaling: {\n      type: \"yarn\",\n      factor: 4.0,\n      originalMaxPositionEmbeddings: 32768,\n    },\n    typicalOutputTokens: 8192,\n  },\n  \"qwen3-coder-30b-a3b-instruct\": {\n    maxPositionEmbeddings: 40960,\n    contextWindow: 131072, // 128K with YaRN - but LM Studio defaults to ~32K\n    supportsExtendedContext: true,\n    ropeScaling: {\n      type: \"yarn\",\n      factor: 4.0,\n      originalMaxPositionEmbeddings: 32768,\n    },\n    typicalOutputTokens: 8192,\n  },\n  \"qwen3-8b\": {\n    maxPositionEmbeddings: 40960,\n    contextWindow: 131072,\n    supportsExtendedContext: true,\n    typicalOutputTokens: 4096,\n  },\n  \"qwen3-14b\": {\n    maxPositionEmbeddings: 40960,\n    contextWindow: 131072,\n    supportsExtendedContext: true,\n    typicalOutputTokens: 4096,\n  },\n  \"qwen3-32b\": {\n    maxPositionEmbeddings: 40960,\n    contextWindow: 131072,\n    supportsExtendedContext: true,\n    typicalOutputTokens: 4096,\n  },\n  \"llama-3.1\": {\n    maxPositionEmbeddings: 131072,\n    contextWindow: 131072,\n    supportsExtendedContext: false,\n    typicalOutputTokens: 8192,\n  },\n  \"llama-3.2\": {\n    maxPositionEmbeddings: 131072,\n    contextWindow: 131072,\n    supportsExtendedContext: false,\n    typicalOutputTokens: 8192,\n  },\n  \"mistral-nemo\": {\n    maxPositionEmbeddings: 131072,\n    contextWindow: 131072,\n    supportsExtendedContext: false,\n    typicalOutputTokens: 8192,\n  },\n  \"gemma-2\": {\n    maxPositionEmbeddings: 8192,\n    contextWindow: 8192,\n    supportsExtendedContext: false,\n    typicalOutputTokens: 4096,\n  },\n};\n\nexport class ModelRegistry {\n  private registryPath: string;\n  private data: ModelRegistryData;\n  private readonly CACHE_TTL_DAYS = 7;\n\n  constructor(memoryDir: string) {\n    this.registryPath = join(memoryDir, \".registry\", \"model-capabilities.json\");\n    this.data = this.loadRegistry();\n  }\n\n  private loadRegistry(): ModelRegistryData {\n    try {\n      if (fs.existsSync(this.registryPath)) {\n        const content = fs.readFileSync(this.registryPath, \"utf-8\");\n        const data = JSON.parse(content) as ModelRegistryData;\n        log.info(`ModelRegistry: loaded ${Object.keys(data.models).length} cached models`);\n        return data;\n      }\n    } catch (err) {\n      log.warn(`ModelRegistry: failed to load registry: ${err}`);\n    }\n    return { models: {}, version: 1 };\n  }\n\n  private saveRegistry(): void {\n    try {\n      // Created on first save, never at construction: building a registry\n      // happens on every plugin registration, including read-only discovery\n      // passes, and must not touch the operator's memory dir.\n      const registryDir = dirname(this.registryPath);\n      if (!fs.existsSync(registryDir)) fs.mkdirSync(registryDir, { recursive: true });\n      fs.writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));\n    } catch (err) {\n      log.warn(`ModelRegistry: failed to save registry: ${err}`);\n    }\n  }\n\n  private isCacheExpired(model: ModelCapabilities): boolean {\n    const fetched = new Date(model.fetchedAt);\n    const now = new Date();\n    const daysDiff = (now.getTime() - fetched.getTime()) / (1000 * 60 * 60 * 24);\n    return daysDiff > this.CACHE_TTL_DAYS;\n  }\n\n  private normalizeModelId(modelId: string): string {\n    // Remove common suffixes and prefixes for matching\n    return modelId\n      .toLowerCase()\n      .replace(/@\\d+bit$/, \"\") // Remove @4bit, @8bit\n      .replace(/-mlx$/, \"\")\n      .replace(/-awq$/, \"\")\n      .replace(/-gptq$/, \"\")\n      .replace(/-gguf$/, \"\")\n      .replace(/^mlx-community\\//, \"\")\n      .replace(/^models\\//, \"\")\n      .trim();\n  }\n\n  /**\n   * Get capabilities for a model, using cache if available\n   */\n  getCapabilities(modelId: string): ModelCapabilities {\n    const normalizedId = this.normalizeModelId(modelId);\n\n    // Check cache first\n    if (this.data.models[normalizedId]) {\n      const cached = this.data.models[normalizedId];\n      if (!this.isCacheExpired(cached)) {\n        log.info(`ModelRegistry: using cached capabilities for ${modelId}`);\n        return cached;\n      }\n      log.info(`ModelRegistry: cache expired for ${modelId}, will refresh`);\n    }\n\n    // Check known models\n    for (const [knownId, capabilities] of Object.entries(KNOWN_MODELS)) {\n      if (normalizedId.includes(knownId)) {\n        log.info(`ModelRegistry: using known capabilities for ${modelId}`);\n        const caps: ModelCapabilities = {\n          ...DEFAULT_CAPABILITIES,\n          ...capabilities,\n          modelId: normalizedId,\n          source: \"default\",\n          fetchedAt: new Date().toISOString(),\n        };\n        this.data.models[normalizedId] = caps;\n        this.saveRegistry();\n        return caps;\n      }\n    }\n\n    // Return defaults\n    log.info(`ModelRegistry: using default capabilities for ${modelId}`);\n    return {\n      ...DEFAULT_CAPABILITIES,\n      modelId: normalizedId,\n    };\n  }\n\n  /**\n   * Store capabilities for a model\n   */\n  setCapabilities(modelId: string, capabilities: Omit<ModelCapabilities, \"modelId\" | \"fetchedAt\">): void {\n    const normalizedId = this.normalizeModelId(modelId);\n    const caps: ModelCapabilities = {\n      ...capabilities,\n      modelId: normalizedId,\n      fetchedAt: new Date().toISOString(),\n    };\n    this.data.models[normalizedId] = caps;\n    this.saveRegistry();\n    log.info(`ModelRegistry: stored capabilities for ${modelId}`);\n  }\n\n  /**\n   * Calculate optimal input/output sizes for a model\n   * @param maxContextOverride - Optional override for max context (e.g., if LLM server defaults to smaller window)\n   */\n  calculateContextSizes(modelId: string, maxContextOverride?: number): {\n    maxInputChars: number;\n    maxOutputTokens: number;\n    description: string;\n  } {\n    const caps = this.getCapabilities(modelId);\n\n    // Use override if provided (e.g., user knows their LLM server limits), otherwise use detected caps\n    const sanitizedOverride =\n      typeof maxContextOverride === \"number\" &&\n      Number.isFinite(maxContextOverride) &&\n      Number.isInteger(maxContextOverride) &&\n      maxContextOverride >= 1024\n        ? maxContextOverride\n        : undefined;\n    const effectiveContextWindow = sanitizedOverride ?? Math.max(1024, Math.floor(caps.contextWindow));\n\n    // Guardrails: never allow output budget to exceed the model/server context window.\n    // If we do, input budget goes negative and we end up generating huge, invalid prompts.\n    const overheadTokens = Math.min(1000, Math.floor(effectiveContextWindow / 10)); // <=10% overhead, max 1k\n    const minInputTokens = Math.min(512, Math.floor(effectiveContextWindow / 4)); // keep some room even on small contexts\n    const minOutputTokens = Math.min(256, Math.max(1, effectiveContextWindow - overheadTokens - minInputTokens));\n\n    // Base output budget: typical output, but scaled down for small contexts.\n    let outputTokens = caps.typicalOutputTokens;\n\n    // For very large contexts, default to ~12.5% output (capped), which tends to be plenty for JSON extraction.\n    if (effectiveContextWindow > 65536) {\n      outputTokens = Math.min(Math.floor(effectiveContextWindow / 8), 16384);\n    }\n\n    // Never let output exceed 25% of context.\n    outputTokens = Math.min(outputTokens, Math.floor(effectiveContextWindow / 4));\n\n    // Clamp output so we always have positive input headroom.\n    const maxOutputTokens = Math.max(1, effectiveContextWindow - overheadTokens - minInputTokens);\n    outputTokens = Math.min(maxOutputTokens, Math.max(minOutputTokens, outputTokens));\n\n    const availableForInput = Math.max(\n      0,\n      effectiveContextWindow - outputTokens - overheadTokens,\n    );\n\n    // Convert to characters (rough estimate: 1 token ≈ 4 chars)\n    const maxInputChars = Math.max(0, Math.floor(availableForInput * 3.5)); // Conservative: 3.5 chars/token\n\n    const source = sanitizedOverride ? \"user override\" : caps.source;\n    return {\n      maxInputChars,\n      maxOutputTokens: outputTokens,\n      description: `${caps.modelId}: ${effectiveContextWindow.toLocaleString()} context (${source}), using ${maxInputChars.toLocaleString()} chars input / ${outputTokens} tokens output`,\n    };\n  }\n\n  /**\n   * Fetch capabilities from Hugging Face (if available)\n   * Returns true if successful\n   */\n  async fetchFromHuggingFace(modelId: string): Promise<boolean> {\n    // This would be implemented to fetch from HF Hub API\n    // For now, we rely on the known models and manual updates\n    log.info(`ModelRegistry: fetchFromHuggingFace not yet implemented for ${modelId}`);\n    return false;\n  }\n\n  /**\n   * List all cached models\n   */\n  listCached(): string[] {\n    return Object.keys(this.data.models);\n  }\n\n  /**\n   * Clear expired cache entries\n   */\n  cleanExpired(): number {\n    const before = Object.keys(this.data.models).length;\n    this.data.models = Object.fromEntries(\n      Object.entries(this.data.models).filter(([_, caps]) => !this.isCacheExpired(caps))\n    );\n    const after = Object.keys(this.data.models).length;\n    const removed = before - after;\n    if (removed > 0) {\n      this.saveRegistry();\n      log.info(`ModelRegistry: cleaned ${removed} expired entries`);\n    }\n    return removed;\n  }\n}\n"],"mappings":"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","names":[]}