@remnic/core 9.54.5 → 9.54.7

package/src/access-surface-catalog.test.ts

@@ -36,6 +36,8 @@ import {
   type HttpRouteEntry,
   type McpToolEntry,
 } from "./access-surface-catalog.js";
+import { SUPPORT_PASSPORT_OWNER_HTTP_ROUTES } from "./support-passport/access-http.js";
+import { SUPPORT_PASSPORT_PUBLIC_HTTP_ROUTES } from "./support-passport/public-http.js";
 
 // #1668: all remaining MCP tools migrated through the strict-schema boundary
 // (recall, capsule, continuity, work, shared-context, peer, dreams, etc.).
@@ -62,7 +64,7 @@ function shortToolName(advertised: string): string {
 
 /** Spin up a server with emitLegacyTools=true and read the deduped short names. */
 async function liveMcpToolShortNames(): Promise<ReadonlySet<string>> {
-  const stub = { briefingEnabled: true } as unknown as EngramAccessService;
+  const stub = { briefingEnabled: true, supportPassportEnabled: true } as unknown as EngramAccessService;
   const server = new EngramMcpServer(stub, { emitLegacyTools: true, codingDecisionVisible: true, architectureCardVisible: true, codegraphVisible: true, sessionDeltaVisible: true, chatVisible: true });
   const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
   const result = (response as { result?: { tools?: Array<{ name: string }> } }).result;
@@ -142,22 +144,35 @@ function formatViolations(violations: readonly CoverageViolation[]): string {
  * catalog row is not a false migration — the surface code must also wire
  * the dispatch.
  */
-function extractMcpDispatchMap(): Map<string, string> {
-  const source = readFileSync(
-    new URL("./access-mcp.ts", import.meta.url),
-    "utf-8",
-  );
+function extractMcpOperationMap(
+  sourceUrl: URL,
+  constantName: string,
+): Map<string, string> {
+  const source = readFileSync(sourceUrl, "utf-8");
   const blockMatch = source.match(
-    /MCP_MIGRATED_OPERATIONS[^{]*\{([\s\S]*?)\}/,
+    new RegExp(`(?:export\\s+)?const\\s+${constantName}[^=]*=\\s*\\{([\\s\\S]*?)\\}\\s*(?:as const)?;`),
   );
-  const body = blockMatch?.[1] ?? "";
+  assert.ok(blockMatch, `could not find ${constantName} in ${sourceUrl.pathname}`);
   const map = new Map<string, string>();
-  for (const m of body.matchAll(/"engram\.(\w+)"\s*:\s*"(\w+)"/g)) {
+  for (const m of blockMatch[1]!.matchAll(/"engram\.(\w+)"\s*:\s*"(\w+)"/g)) {
     map.set(m[1]!, m[2]!);
   }
   return map;
 }
 
+function extractMcpDispatchMap(): Map<string, string> {
+  return new Map([
+    ...extractMcpOperationMap(
+      new URL("./access-mcp.ts", import.meta.url),
+      "MCP_MIGRATED_OPERATIONS",
+    ),
+    ...extractMcpOperationMap(
+      new URL("./support-passport/mcp-tools.ts", import.meta.url),
+      "SUPPORT_PASSPORT_MCP_MIGRATED_OPERATIONS",
+    ),
+  ]);
+}
+
 /**
  * Normalize a regex route body (e.g. `\/engram\/v1\/peers\/([^/]+)`) to the
  * catalog pathname form (`/engram/v1/peers/:id`).
@@ -302,6 +317,21 @@ function extractHttpRouteDispatchMap(): Map<string, Set<string>> {
       }
     }
   }
+  for (const [sourcePath, routes] of [
+    ["./support-passport/access-http.ts", SUPPORT_PASSPORT_OWNER_HTTP_ROUTES],
+    ["./support-passport/public-http.ts", SUPPORT_PASSPORT_PUBLIC_HTTP_ROUTES],
+  ] as const) {
+    const routeSource = readFileSync(new URL(sourcePath, import.meta.url), "utf-8");
+    for (const route of routes) {
+      const dynamicCardMutation =
+        route.operation.startsWith("support_passport_card_") &&
+        routeSource.includes("operation = `support_passport_card_${cardMatch[2]}`");
+      const publicDispatch = new RegExp(`runPublicOperation\\(\\s*service,\\s*"${route.operation}"`).test(routeSource);
+      if (routeSource.includes(`operation = "${route.operation}"`) || dynamicCardMutation || publicDispatch) {
+        routeOps.set(`${route.method} ${route.pathname}`, new Set([route.operation]));
+      }
+    }
+  }
   return routeOps;
 }
 
@@ -824,4 +854,4 @@ test("memory_get operation resolves through the boundary without hooks (read par
     { service },
   )) as { result: { found: boolean } };
   assert.equal(output.result.found, false);
-});
+});

package/src/access-surface-catalog.ts

@@ -22,6 +22,8 @@
  */
 
 import type { OperationName } from "./access-boundary.js";
+import { SUPPORT_PASSPORT_OWNER_HTTP_ROUTES } from "./support-passport/access-http.js";
+import { SUPPORT_PASSPORT_PUBLIC_HTTP_ROUTES } from "./support-passport/public-http.js";
 
 /**
  * One row per MCP tool, keyed by the canonical SHORT name (no `engram.`/
@@ -162,6 +164,17 @@ export const MCP_TOOLS: readonly McpToolEntry[] = [
   { tool: "console_state", operation: "console_state" },
   { tool: "dreams_status", operation: "dreams_status" },
   { tool: "dreams_run", operation: "dreams_run" },
+  { tool: "support_passport_memory_preview", operation: "support_passport_memory_preview" },
+  { tool: "support_passport_cards_list", operation: "support_passport_cards_list" },
+  { tool: "support_passport_draft_create", operation: "support_passport_draft_create" },
+  { tool: "support_passport_drafts_generate", operation: "support_passport_drafts_generate" },
+  { tool: "support_passport_card_replace", operation: "support_passport_card_replace" },
+  { tool: "support_passport_card_approve", operation: "support_passport_card_approve" },
+  { tool: "support_passport_card_reject", operation: "support_passport_card_reject" },
+  { tool: "support_passport_card_withdraw", operation: "support_passport_card_withdraw" },
+  { tool: "support_passport_grant_create", operation: "support_passport_grant_create" },
+  { tool: "support_passport_grants_list", operation: "support_passport_grants_list" },
+  { tool: "support_passport_grant_revoke", operation: "support_passport_grant_revoke" },
 ];
 
 // Each route below corresponds 1:1 to a service-invoking route branch in
@@ -260,6 +273,8 @@ export const HTTP_ROUTES: readonly HttpRouteEntry[] = [
   { method: "GET", pathname: "/engram/v1/graph/events", operation: "graph_events" },
   { method: "POST", pathname: "/engram/v1/chat/message", operation: "chat_message" },
   { method: "GET", pathname: "/engram/v1/chat/events/:id", operation: "chat_events" },
+  ...SUPPORT_PASSPORT_OWNER_HTTP_ROUTES,
+  ...SUPPORT_PASSPORT_PUBLIC_HTTP_ROUTES,
 ];
 
 /**

package/src/active-memory-bridge.ts

@@ -1,9 +1,9 @@
 import { resolveNamespaceCapabilities } from "./capabilities.js";
 import { canReadNamespace, defaultNamespaceForPrincipal, resolvePrincipal } from "./namespaces/principal.js";
-import type { MemoryFile, PluginConfig, QmdSearchResult } from "./types.js";
-import { collapseWhitespace, truncateCodePointSafe } from "./whitespace.js";
 import { isHandleToken } from "./recall-handles.js";
 import { isSupportPassportPrivateMemory } from "./support-passport/card-projection.js";
+import type { MemoryFile, PluginConfig, QmdSearchResult } from "./types.js";
+import { collapseWhitespace, truncateCodePointSafe } from "./whitespace.js";
 
 export interface ActiveMemoryMetadata {
   type?: "fact" | "preference";
@@ -39,14 +39,16 @@ export interface ActiveMemoryRecallParams {
   snippetMaxChars?: number;
 }
 
+interface ActiveMemoryStorage {
+  readMemoryByPath?: (path: string) => Promise<MemoryFile | null>;
+  getMemoryById?: (id: string) => Promise<MemoryFile | null>;
+}
+
 interface ActiveMemoryScopedOrchestrator {
   config?: PluginConfig;
   resolvePrincipal?: (sessionKey?: string) => string | undefined;
   resolveSelfNamespace?: (sessionKey?: string) => string;
-  getStorageForNamespace?: (namespace: string) => Promise<{
-    readMemoryByPath?: (path: string) => Promise<MemoryFile | null>;
-    getMemoryById?: (id: string) => Promise<MemoryFile | null>;
-  }>;
+  getStorageForNamespace?: (namespace: string) => Promise<ActiveMemoryStorage>;
   filterPrivateSearchResults?: (
     results: QmdSearchResult[],
     namespaces?: readonly string[],
@@ -71,13 +73,13 @@ function isArtifactPath(value: string | undefined): boolean {
 async function filterVisibleActiveMemoryCandidates(
   orchestrator: ActiveMemoryScopedOrchestrator,
   namespace: string,
-  storage: Awaited<ReturnType<NonNullable<ActiveMemoryScopedOrchestrator["getStorageForNamespace"]>>> | undefined,
+  storage: ActiveMemoryStorage | undefined,
   candidates: ActiveMemorySearchCandidate[],
   visibilityCache?: Map<string, boolean>,
 ): Promise<ActiveMemorySearchCandidate[]> {
   const visible = new Set<ActiveMemorySearchCandidate>();
   const pathCandidates = candidates.filter(
-    (candidate) => typeof candidate.path === "string" && !isArtifactPath(candidate.path),
+    (candidate) => typeof candidate.path === "string" && !isArtifactPath(candidate.path)
   );
   if (pathCandidates.length > 0 && typeof orchestrator.filterPrivateSearchResults === "function") {
     const qmdCandidates = pathCandidates.map((candidate): QmdSearchResult => ({
@@ -100,14 +102,14 @@ async function filterVisibleActiveMemoryCandidates(
   }
 
   const idCandidates = candidates.filter(
-    (candidate) => candidate.path === undefined && typeof candidate.id === "string",
+    (candidate) => candidate.path === undefined && typeof candidate.id === "string"
   );
   if (storage) {
     const idVisibility = await Promise.all(
       idCandidates.map(async (candidate) => {
         const memory = await storage.getMemoryById?.(candidate.id!);
         return memory !== null && memory !== undefined && !isSupportPassportPrivateMemory(memory);
-      }),
+      })
     );
     idCandidates.forEach((candidate, index) => {
       if (idVisibility[index]) visible.add(candidate);
@@ -139,7 +141,7 @@ function pickMetadata(value: Record<string, unknown> | undefined): ActiveMemoryM
 function resolveActiveMemoryNamespace(
   orchestrator: ActiveMemoryScopedOrchestrator,
   sessionKey: string | undefined,
-  requestedNamespace: string | undefined,
+  requestedNamespace: string | undefined
 ): string {
   const explicitNamespace =
     typeof requestedNamespace === "string" && requestedNamespace.trim().length > 0
@@ -195,7 +197,7 @@ export async function recallForActiveMemory(
       mode?: string;
     }) => Promise<ActiveMemorySearchCandidate[]>;
   },
-  params: ActiveMemoryRecallParams,
+  params: ActiveMemoryRecallParams
 ): Promise<ActiveMemorySearchOutput> {
   const limit = clampLimit(params.limit);
   const snippetMaxChars =
@@ -205,7 +207,7 @@ export async function recallForActiveMemory(
   const namespace = resolveActiveMemoryNamespace(
     orchestrator,
     params.sessionKey,
-    typeof params.filters?.namespace === "string" ? params.filters.namespace : undefined,
+    typeof params.filters?.namespace === "string" ? params.filters.namespace : undefined
   );
 
   const storage = await orchestrator.getStorageForNamespace?.(namespace);
@@ -277,13 +279,9 @@ export async function getMemoryForActiveMemory(
   options: {
     namespace?: string;
     sessionKey?: string;
-  } = {},
+  } = {}
 ): Promise<ActiveMemoryGetOutput> {
-  const namespace = resolveActiveMemoryNamespace(
-    orchestrator,
-    options.sessionKey,
-    options.namespace,
-  );
+  const namespace = resolveActiveMemoryNamespace(orchestrator, options.sessionKey, options.namespace);
 
   const storage =
     typeof orchestrator.getStorageForNamespace === "function"

package/src/config.ts

@@ -66,6 +66,7 @@ import { parseProvenanceConfig } from "./provenance.js";
 import { parseBoundedJsonlStateConfig } from "./bounded-jsonl-state.js";
 import { parseCodingKnowledgeConfig } from "./coding/coding-knowledge-config.js";
 import { parseChatConfig } from "./chat/chat-config.js";
+import { parseSupportPassportConfig } from "./support-passport/config.js";
 import { parseCorrectionIntentConfig, parseFaithfulnessGateConfig } from "./faithfulness-config.js";
 import { parseOfflineSyncExcludes } from "./offline-sync.js";
 import { parseExternalWikiRoots } from "./external-wiki-config.js";
@@ -469,23 +470,27 @@ export function resolveEnvVars(value: string): string {
 }
 
 function normalizeOpenaiBaseUrl(value: string | undefined, source: "config" | "env"): string | undefined {
-  if (!value) return undefined;
+  if (value === undefined) return undefined;
   const trimmed = value.trim();
-  if (trimmed.length === 0) return undefined;
+  if (trimmed.length === 0) {
+    throw new Error(`${source === "env" ? "OPENAI_BASE_URL" : "openaiBaseUrl"} must be an absolute HTTP or HTTPS URL`);
+  }
 
   let parsed: URL;
   try {
     parsed = new URL(trimmed);
   } catch {
-    log.warn(`ignoring invalid openaiBaseUrl from ${source}: not a valid URL`);
-    return undefined;
+    throw new Error(`${source === "env" ? "OPENAI_BASE_URL" : "openaiBaseUrl"} must be an absolute HTTP or HTTPS URL`);
   }
 
   if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
-    log.warn(
-      `ignoring openaiBaseUrl from ${source}: unsupported URL scheme (${parsed.protocol.replace(":", "")})`,
+    throw new Error(`${source === "env" ? "OPENAI_BASE_URL" : "openaiBaseUrl"} must use HTTP or HTTPS`);
+  }
+
+  if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+    throw new Error(
+      `${source === "env" ? "OPENAI_BASE_URL" : "openaiBaseUrl"} must not include credentials, query parameters, or fragments`,
     );
-    return undefined;
   }
 
   if (parsed.protocol === "http:") {
@@ -1461,9 +1466,12 @@ export function parseConfig(
   };
 
   let baseUrl: string | undefined;
-  if (typeof cfg.openaiBaseUrl === "string" && cfg.openaiBaseUrl.length > 0) {
+  if (cfg.openaiBaseUrl !== undefined && typeof cfg.openaiBaseUrl !== "string") {
+    throw new Error("openaiBaseUrl must be a string");
+  }
+  if (cfg.openaiBaseUrl !== undefined) {
     baseUrl = normalizeOpenaiBaseUrl(resolveEnvVars(cfg.openaiBaseUrl), "config");
-  } else {
+  } else if (apiKey !== undefined) {
     baseUrl = normalizeOpenaiBaseUrl(readEnvVar("OPENAI_BASE_URL"), "env");
   }
 
@@ -2325,6 +2333,7 @@ export function parseConfig(
     codexCompat,
     codingKnowledge: parseCodingKnowledgeConfig(cfg.codingKnowledge),
     chat: parseChatConfig(cfg.chat),
+    supportPassport: parseSupportPassportConfig(cfg.supportPassport),
     hourlySummariesEnabled: cfg.hourlySummariesEnabled !== false, // default: true
     daySummaryEnabled: cfg.daySummaryEnabled !== false, // default: true
     hourlySummaryCronAutoRegister: cfg.hourlySummaryCronAutoRegister === true,

package/src/fallback-llm.test.ts

@@ -4,6 +4,7 @@ import test from "node:test";
 
 import { FallbackLlmClient, gatewayTaskChainOptions } from "./fallback-llm.js";
 import { __codexCliFallbackTestHooks } from "./cli-fallback.js";
+import { initLogger, resetLogger } from "./logger.js";
 import { clearModelsJsonCache, __setModelsJsonForTest } from "./models-json.js";
 import {
   __setGatewayRuntimeAuthForModelForTest,
@@ -1654,6 +1655,59 @@ test("fallback llm does NOT append default for a primary-less override that fall
   }
 });
 
+test("fallback llm redacts provider error bodies for sensitive calls", { concurrency: false }, async () => {
+  clearModelsJsonCache();
+  clearSecretCache();
+  const privateMarker = "private-support-note-must-not-log";
+  const lines: string[] = [];
+  initLogger(
+    {
+      info: (message) => lines.push(message),
+      warn: (message) => lines.push(message),
+      error: (message) => lines.push(message),
+      debug: (message) => lines.push(message),
+    },
+    true,
+    { timestamps: false },
+  );
+  const llm = new FallbackLlmClient({
+    agents: { defaults: { model: { primary: "private-provider/test-model" } } },
+    models: {
+      providers: {
+        "private-provider": {
+          baseUrl: "https://private-provider.example/v1",
+          api: "openai-completions",
+          apiKey: "test-key",
+          models: [],
+        },
+      },
+    },
+  });
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = (async () =>
+    new Response(JSON.stringify({ error: { message: privateMarker } }), {
+      status: 400,
+      headers: { "content-type": "application/json" },
+    })) as typeof fetch;
+
+  try {
+    assert.equal(
+      await llm.chatCompletion(
+        [{ role: "user", content: privateMarker }],
+        { redactProviderErrors: true },
+      ),
+      null,
+    );
+    assert.equal(lines.join("\n").includes(privateMarker), false);
+    assert.match(lines.join("\n"), /provider error details redacted/);
+  } finally {
+    globalThis.fetch = originalFetch;
+    resetLogger();
+    clearModelsJsonCache();
+    clearSecretCache();
+  }
+});
+
 function disableGatewaySecretResolverForTest(): void {
   __setGatewayResolverForTest(async () => null);
 }

package/src/fallback-llm.ts

@@ -23,12 +23,22 @@ export interface FallbackLlmOptions {
   maxTokens?: number;
   timeoutMs?: number;
   signal?: AbortSignal;
+  /** Set the Responses API storage policy. Other transports ignore this value. */
+  store?: boolean;
+  /** Request strict JSON output when a route uses the Responses API. */
+  responsesJsonSchema?: { name: string; schema: Record<string, unknown> };
+  /** Hide provider error details that could echo private request content. */
+  redactProviderErrors?: boolean;
   /** Explicit "provider/model" override to try before the configured chain. */
   model?: string;
   /** Explicit model chain override to use instead of the configured agent/default chain. */
   modelChain?: AgentPersonaModelConfig;
+  /** Append the gateway default chain after an explicit model chain. */
+  includeDefaultModelFallback?: boolean;
   /** Override which agent persona's model chain to use (by ID from agents.list[]). */
   agentId?: string;
+  /** Reject a transport-successful response and continue through the configured model chain. */
+  acceptResponse?: (response: FallbackLlmResponse) => boolean;
 }
 
 export interface FallbackLlmAvailabilityOptions {
@@ -177,7 +187,12 @@ export class FallbackLlmClient {
     messages: Array<{ role: "system" | "user" | "assistant"; content: string }>,
     options: FallbackLlmOptions = {},
   ): Promise<FallbackLlmResponse | null> {
-    const models = this.getModelChain(options.agentId, options.model, options.modelChain);
+    const models = this.getModelChain(
+      options.agentId,
+      options.model,
+      options.modelChain,
+      options.includeDefaultModelFallback,
+    );
     if (models.length === 0) {
       log.warn("fallback LLM: no models configured in gateway");
       return null;
@@ -186,6 +201,7 @@ export class FallbackLlmClient {
     const runChain = async (
       runOptions: FallbackLlmOptions,
     ): Promise<FallbackLlmResponse | null> => {
+      let lastRejectedResponse: FallbackLlmResponse | null = null;
       // Try each model in the chain
       for (let i = 0; i < models.length; i++) {
         if (runOptions.signal?.aborted) {
@@ -197,27 +213,37 @@ export class FallbackLlmClient {
         try {
           const result = await this.tryModel(model, messages, runOptions);
           if (result) {
-            if (isFallback) {
-              log.debug(`fallback LLM: succeeded using ${model.modelString} (fallback ${i})`);
-            }
-            return {
+            const response = {
               content: result.content,
               modelUsed: model.modelString,
               usage: result.usage,
             };
+            if (runOptions.acceptResponse && !runOptions.acceptResponse(response)) {
+              lastRejectedResponse = response;
+              log.debug(`fallback LLM: ${model.modelString} returned rejected output, trying next...`);
+              continue;
+            }
+            if (isFallback) {
+              log.debug(`fallback LLM: succeeded using ${model.modelString} (fallback ${i})`);
+            }
+            return response;
           }
         } catch (err) {
           if (runOptions.signal?.aborted) {
             throw abortReason(runOptions.signal);
           }
-          const errorMsg = err instanceof Error ? err.message : String(err);
+          const errorMsg = runOptions.redactProviderErrors
+            ? "provider error details redacted"
+            : err instanceof Error
+              ? err.message
+              : String(err);
           log.debug(`fallback LLM: ${model.modelString} failed (${errorMsg}), trying next...`);
           // Continue to next model in chain
         }
       }
 
       log.warn(`fallback LLM: all ${models.length} models in chain failed`);
-      return null;
+      return lastRejectedResponse;
     };
 
     if (typeof options.timeoutMs === "number") {
@@ -301,7 +327,12 @@ export class FallbackLlmClient {
       // Disambiguate via the resolved model chain so the retry layer can pick
       // the right failure class.
       const hasModels =
-        this.getModelChain(options.agentId, options.model, options.modelChain).length > 0;
+        this.getModelChain(
+          options.agentId,
+          options.model,
+          options.modelChain,
+          options.includeDefaultModelFallback,
+        ).length > 0;
       return { result: null, failureReason: hasModels ? "http_error" : "no_models" };
     }
 
@@ -335,6 +366,7 @@ export class FallbackLlmClient {
     agentId?: string,
     modelOverride?: string,
     modelChainOverride?: AgentPersonaModelConfig,
+    includeDefaultModelFallback = true,
   ): ModelRef[] {
     const chain: ModelRef[] = [];
     const providers = this.gatewayConfig?.models?.providers ?? {};
@@ -402,7 +434,7 @@ export class FallbackLlmClient {
     // the SAME activation condition chain resolution uses above — so a
     // primary-less override (e.g. {}) that falls through to a persona/default
     // chain does NOT get the default appended (gotcha #39). Issue #1365 / PR #1370.
-    if (modelChainOverride?.primary && modelStrings.length > 0) {
+    if (includeDefaultModelFallback && modelChainOverride?.primary && modelStrings.length > 0) {
       // Append the FULL gateway default chain (primary + fallbacks), not just
       // the primary — if the default primary is also unreachable, a listed
       // default fallback may still succeed (cursor review #1425).
@@ -858,6 +890,19 @@ export class FallbackLlmClient {
       ...buildChatCompletionTemperature(modelId, options.temperature ?? 0.3, {
         assumeOpenAI: shouldAssumeOpenAiChatCompletions(config.baseUrl),
       }),
+      ...(options.store === undefined ? {} : { store: options.store }),
+      ...(options.responsesJsonSchema
+        ? {
+            text: {
+              format: {
+                type: "json_schema",
+                name: options.responsesJsonSchema.name,
+                strict: true,
+                schema: options.responsesJsonSchema.schema,
+              },
+            },
+          }
+        : {}),
     };
     if (instructions.length > 0) {
       body.instructions = instructions;

package/src/inline-script.ts

@@ -0,0 +1,6 @@
+export function serializeInlineScriptValue(value: string): string {
+  return JSON.stringify(value)
+    .replaceAll("<", "\\u003c")
+    .replaceAll("\u2028", "\\u2028")
+    .replaceAll("\u2029", "\\u2029");
+}

package/src/local-llm-headers-timeout.test.ts

@@ -13,6 +13,7 @@ import {
 
 import { LocalLlmClient } from "./local-llm.js";
 import { ChatTransport } from "./local-llm-transport.js";
+import { initLogger, resetLogger } from "./logger.js";
 import type { PluginConfig } from "./types.js";
 
 /**
@@ -511,3 +512,44 @@ test("availability probes stop after the caller aborts", async () => {
     await new Promise<void>((resolve) => server.close(() => resolve()));
   }
 });
+
+test("sensitive local requests do not log provider error bodies", { concurrency: false }, async () => {
+  const original = globalThis.fetch;
+  const privateMarker = "private-local-support-note-must-not-log";
+  const privateStatusText = "private-provider-status-must-not-log";
+  const lines: string[] = [];
+  initLogger(
+    {
+      info: (message) => lines.push(message),
+      warn: (message) => lines.push(message),
+      error: (message) => lines.push(message),
+      debug: (message) => lines.push(message),
+    },
+    true,
+    { timestamps: false },
+  );
+  globalThis.fetch = (async () =>
+    new Response(JSON.stringify({ error: { message: privateMarker } }), {
+      status: 400,
+      statusText: privateStatusText,
+      headers: { "content-type": "application/json" },
+    })) as typeof fetch;
+  const client = new LocalLlmClient(createConfig());
+
+  try {
+    primeClient(client);
+    assert.equal(
+      await client.chatCompletion(
+        [{ role: "user", content: privateMarker }],
+        { redactProviderErrors: true },
+      ),
+      null,
+    );
+    assert.equal(lines.join("\n").includes(privateMarker), false);
+    assert.equal(lines.join("\n").includes(privateStatusText), false);
+  } finally {
+    globalThis.fetch = original;
+    resetLogger();
+    await dispatcherOf(client).close();
+  }
+});

package/src/local-llm.ts

@@ -235,8 +235,8 @@ interface LocalLlmChatCompletionOptions {
   disableThinking?: boolean;
   priority?: LocalLlmRequestPriority;
   signal?: AbortSignal;
+  redactProviderErrors?: boolean;
 }
-
 interface LocalLlmQueuedRequest {
   messages: Array<{ role: string; content: string }>;
   options: LocalLlmChatCompletionOptions;
@@ -917,7 +917,7 @@ export class LocalLlmClient {
           enqueuedAtMs: next.enqueuedAtMs,
         });
       } catch (err) {
-        log.warn(`local LLM queue drain failed open: ${err instanceof Error ? err.message : String(err)}`);
+        log.warn(`local LLM queue drain failed open: ${next.options.redactProviderErrors ? "provider error details redacted" : err instanceof Error ? err.message : String(err)}`);
       }
       next.resolve(result);
     } finally {
@@ -1071,7 +1071,7 @@ export class LocalLlmClient {
             break;
           }
           if (response && !response.ok) {
-            log.debug(`local LLM failed to read ${response.status} response body: ${error.message}`);
+            log.debug(`local LLM failed to read ${response.status} response body: ${options.redactProviderErrors ? "details redacted" : error.message}`);
           } else {
             response = null;
             if (!isAbortError(err)) throw err;
@@ -1132,10 +1132,10 @@ export class LocalLlmClient {
           const parsed = JSON.parse(responseBody) as { error?: { message?: string } };
           reason = parsed?.error?.message ? ` — ${parsed.error.message}` : "";
         } catch {
-          log.debug(`local LLM error body: ${responseBody.slice(0, 500)}`);
+          if (!options.redactProviderErrors) log.debug(`local LLM error body: ${responseBody.slice(0, 500)}`);
         }
         log.warn(
-          `local LLM request failed: ${response.status} ${response.statusText}${reason} ` +
+          `local LLM request failed: ${response.status}${options.redactProviderErrors ? "" : ` ${response.statusText}${reason}`} ` +
           `(op=${operation}, model=${this.config.localLlmModel}, url=${chatUrl}, promptChars=${promptChars}, maxTokens=${requestBody.max_tokens as number})`,
         );
         const nonRecoverableReason =
@@ -1187,7 +1187,7 @@ export class LocalLlmClient {
       const msg = data.choices?.[0]?.message;
       const content = msg?.content || msg?.reasoning_content || "";
       if (!content) {
-        log.warn(`local LLM returned empty content. choices=${JSON.stringify(data.choices)?.slice(0, 200)}`);
+        log.warn(`local LLM returned empty content.${options.redactProviderErrors ? "" : ` choices=${JSON.stringify(data.choices)?.slice(0, 200)}`}`);
         return null;
       }
 
@@ -1216,11 +1216,11 @@ export class LocalLlmClient {
       const durationMs = Date.now() - startedAtMs;
       if (isAbortError(err)) {
         log.warn(
-          `local LLM request aborted: op=${operation} timeoutMs=${options.timeoutMs ?? this.config.localLlmTimeoutMs} model=${this.config.localLlmModel} durationMs=${durationMs} error=${errMsg}`,
+          `local LLM request aborted: op=${operation} timeoutMs=${options.timeoutMs ?? this.config.localLlmTimeoutMs} model=${this.config.localLlmModel} durationMs=${durationMs} error=${options.redactProviderErrors ? "provider error details redacted" : errMsg}`,
         );
         return null;
       }
-      log.warn(`local LLM request error: op=${operation} error=${errMsg}`);
+      log.warn(`local LLM request error: op=${operation} error=${options.redactProviderErrors ? "provider error details redacted" : errMsg}`);
       this.isAvailable = false; // Mark as unavailable on non-abort errors
       const nonRecoverableReason = extractNonRecoverableBackendReason(errMsg);
       if (nonRecoverableReason) {

package/src/mcp-read-only-tools.ts

@@ -61,4 +61,7 @@ export const MCP_READ_ONLY_TOOL_SUFFIXES: Readonly<Record<string, true>> = {
   codegraph_get_snippet: true,
   codegraph_get_architecture: true,
   codegraph_search_code: true,
+  support_passport_memory_preview: true,
+  support_passport_cards_list: true,
+  support_passport_grants_list: true,
 };