@centerforagenticai/pi-multi-account 0.1.4 → 0.1.6

package/src/diagnostic-store.ts

@@ -12,7 +12,11 @@ import { randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
 import {
 	sanitizeDiagnosticText,
+	projectResponseHeaders,
+	isHeaderDiagnostic,
+	HEADER_DIAGNOSTIC_MESSAGE,
 	sanitizeForJson,
+	retainDiagnosticEvents,
 	type DiagnosticEvent,
 	type DiagnosticLevel,
 	type DiagnosticPersistence,
@@ -84,13 +88,16 @@ function projectEvent(value: unknown): DiagnosticEvent | undefined {
 	if (typeof candidate.level !== "string" || !LEVELS.has(candidate.level as DiagnosticLevel)) {
 		return undefined;
 	}
-	const fields = projectFields(candidate.fields);
+	const fields = isHeaderDiagnostic(candidate.category, candidate.message)
+		? projectResponseHeaders(candidate.fields)
+		: projectFields(candidate.fields);
 	if (fields === undefined) return undefined;
 	return {
 		timestampMs: candidate.timestampMs,
 		level: candidate.level as DiagnosticLevel,
 		category: sanitizeDiagnosticText(candidate.category),
-		message: sanitizeDiagnosticText(candidate.message),
+		message: isHeaderDiagnostic(candidate.category, candidate.message)
+			? HEADER_DIAGNOSTIC_MESSAGE : sanitizeDiagnosticText(candidate.message),
 		fields,
 	};
 }
@@ -110,20 +117,15 @@ function parseCompleteEvents(raw: string): readonly DiagnosticEvent[] {
 	return events;
 }
 
-function newestLinesWithin(
+function priorityLinesWithin(
 	events: readonly DiagnosticEvent[],
 	budgetBytes: number,
 ): string {
-	const retained: string[] = [];
-	let used = 0;
-	for (let index = events.length - 1; index >= 0; index -= 1) {
-		const line = `${JSON.stringify(events[index])}\n`;
-		const bytes = Buffer.byteLength(line, "utf8");
-		if (bytes > budgetBytes - used) break;
-		retained.push(line);
-		used += bytes;
-	}
-	return retained.reverse().join("");
+	return retainDiagnosticEvents(
+		events,
+		budgetBytes,
+		(event) => Buffer.byteLength(`${JSON.stringify(event)}\n`, "utf8"),
+	).map((event) => `${JSON.stringify(event)}\n`).join("");
 }
 
 /** Machine-global, credential-free, bounded diagnostic event history. */
@@ -164,7 +166,7 @@ export class DiagnosticStore implements DiagnosticPersistence {
 			: 100;
 		if (safeLimit === 0) return [];
 		try {
-			return parseCompleteEvents(readFileSync(this.#path, "utf8")).slice(-safeLimit);
+			return retainDiagnosticEvents(parseCompleteEvents(readFileSync(this.#path, "utf8")), safeLimit);
 		} catch {
 			return [];
 		}
@@ -251,7 +253,7 @@ export class DiagnosticStore implements DiagnosticPersistence {
 				Math.floor(this.#maxBytes / 2),
 				this.#maxBytes - tailBytes,
 			);
-			const compacted = newestLinesWithin(events, targetBytes);
+			const compacted = priorityLinesWithin(events, targetBytes);
 			const encoded = compacted + tail;
 			if (Buffer.byteLength(encoded, "utf8") > this.#maxBytes) return false;
 			temporaryPath = `${this.#path}.${process.pid}.${randomUUID()}.tmp`;

package/src/diagnostics.ts

@@ -2,17 +2,38 @@ const MAX_DIAGNOSTIC_LENGTH = 512;
 const REDACTED = "[REDACTED]";
 const SENSITIVE_NAME_FRAGMENT = /(?:authorization|authentication|auth|token|credential|secret|cookie|apikey)/;
 const PRIVATE_REASONING_KEY = /^(?:thinking|reasoning)/;
-const TOKEN_QUOTA_REMAINING_HEADERS = new Set([
-  "x-ratelimit-remaining-tokens",
-  "x-ratelimit-tokens-remaining",
-  "anthropic-ratelimit-tokens-remaining",
+// Closed response observations: unknown names (including identifiers) never cross
+// the callback or retained-diagnostic boundary, even when their value looks safe.
+const COUNT_HEADERS = new Set([
+  "x-ratelimit-remaining", "x-ratelimit-remaining-requests", "x-ratelimit-requests-remaining",
+  "x-ratelimit-remaining-tokens", "x-ratelimit-tokens-remaining",
+  "anthropic-ratelimit-requests-remaining", "anthropic-ratelimit-tokens-remaining",
+  "x-ratelimit-limit-requests", "x-ratelimit-limit-tokens",
+  "anthropic-ratelimit-requests-limit", "anthropic-ratelimit-tokens-limit",
+  "retry-after-ms",
 ]);
-const TOKEN_QUOTA_DURATION_RESET_HEADERS = new Set([
-  "x-ratelimit-reset-tokens",
+const DURATION_RESET_HEADERS = new Set(["x-ratelimit-reset-requests", "x-ratelimit-reset-tokens"]);
+const ABSOLUTE_RESET_HEADERS = new Set([
+  "x-ratelimit-reset", "anthropic-ratelimit-requests-reset", "anthropic-ratelimit-tokens-reset",
+  "x-codex-primary-reset-at", "x-codex-secondary-reset-at",
 ]);
-const TOKEN_QUOTA_ABSOLUTE_RESET_HEADERS = new Set([
-  "anthropic-ratelimit-tokens-reset",
+const SECONDS_HEADERS = new Set([
+  "x-codex-primary-reset-after-seconds", "x-codex-secondary-reset-after-seconds",
 ]);
+const PERCENT_HEADERS = new Set(["x-codex-primary-used-percent", "x-codex-secondary-used-percent"]);
+const UTILIZATION_HEADERS = new Set([
+  "anthropic-ratelimit-unified-5h-utilization", "anthropic-ratelimit-unified-7d-utilization",
+  "anthropic-ratelimit-unified-7d-sonnet-utilization", "anthropic-ratelimit-unified-7d-opus-utilization",
+]);
+const STATUS_HEADERS = new Set(["anthropic-ratelimit-unified-status"]);
+const RESPONSE_HEADER_NAMES = new Set([
+  ...COUNT_HEADERS, ...DURATION_RESET_HEADERS, ...ABSOLUTE_RESET_HEADERS,
+  ...SECONDS_HEADERS, ...PERCENT_HEADERS, ...UTILIZATION_HEADERS, ...STATUS_HEADERS, "retry-after",
+]);
+export const HEADER_DIAGNOSTIC_MESSAGE = "Provider response headers observed.";
+export function isHeaderDiagnostic(category: unknown, message: unknown): boolean {
+  return category === "provider.response" || message === HEADER_DIAGNOSTIC_MESSAGE;
+}
 
 export type DiagnosticLevel = "info" | "warning" | "error";
 
@@ -128,22 +149,22 @@ function validAbsoluteReset(value: string): boolean {
   return Number.isFinite(epochMs) && epochMs >= 0 && new Date(epochMs).toUTCString() === value;
 }
 
-function validatedTokenQuotaValue(name: string, value: unknown): string | undefined {
+function validatedResponseHeaderValue(name: string, value: unknown): string | undefined {
   const normalized = name.toLowerCase();
-  const isTokenQuotaHeader = TOKEN_QUOTA_REMAINING_HEADERS.has(normalized)
-    || TOKEN_QUOTA_DURATION_RESET_HEADERS.has(normalized)
-    || TOKEN_QUOTA_ABSOLUTE_RESET_HEADERS.has(normalized);
-  if (!isTokenQuotaHeader || typeof value !== "string") return undefined;
-
-  const trimmed = value.trim();
-  if (value !== trimmed) return undefined;
-  if (TOKEN_QUOTA_REMAINING_HEADERS.has(normalized)) {
-    return validTokenCount(trimmed) ? trimmed : undefined;
+  if (!RESPONSE_HEADER_NAMES.has(normalized) || typeof value !== "string" || value !== value.trim()) return undefined;
+  if (COUNT_HEADERS.has(normalized)) return validTokenCount(value) ? value : undefined;
+  if (DURATION_RESET_HEADERS.has(normalized)) {
+    return validDuration(value) || validAbsoluteReset(value) ? value : undefined;
   }
-  if (TOKEN_QUOTA_DURATION_RESET_HEADERS.has(normalized)) {
-    return validDuration(trimmed) || validAbsoluteReset(trimmed) ? trimmed : undefined;
+  if (ABSOLUTE_RESET_HEADERS.has(normalized)) return validAbsoluteReset(value) ? value : undefined;
+  if (STATUS_HEADERS.has(normalized)) {
+    return ["allowed", "allowed_warning", "rejected"].includes(value) ? value : undefined;
   }
-  return validAbsoluteReset(trimmed) ? trimmed : undefined;
+  if (normalized === "retry-after" && validAbsoluteReset(value)) return value;
+  if (value.length > 32 || !/^\d+(?:\.\d+)?$/.test(value)) return undefined;
+  const number = Number(value);
+  const maximum = PERCENT_HEADERS.has(normalized) ? 100 : UTILIZATION_HEADERS.has(normalized) ? 1 : Number.MAX_SAFE_INTEGER / 1000;
+  return Number.isFinite(number) && number >= 0 && number <= maximum ? value : undefined;
 }
 
 /** Sanitizes and bounds one upstream-derived diagnostic value before storage. */
@@ -151,11 +172,20 @@ export function sanitizeDiagnosticText(value: unknown): string {
   return bound(redactDiagnosticText(value));
 }
 
-/** Sensitive headers are replaced wholesale except for strictly validated token-quota observations. */
+/** Compatibility scalar API; unsupported names and malformed observations are redacted. */
 export function sanitizeHeaderValue(name: string, value: unknown): string {
-  const tokenQuotaValue = validatedTokenQuotaValue(name, value);
-  if (tokenQuotaValue !== undefined) return tokenQuotaValue;
-  return isSensitiveName(name) ? REDACTED : sanitizeDiagnosticText(value);
+  return validatedResponseHeaderValue(name, value) ?? REDACTED;
+}
+
+/** Copy only named, validated quota/retry facts. Never retain caller keys or prose. */
+export function projectResponseHeaders(headers: unknown): Record<string, string> {
+  const projected: Record<string, string> = {};
+  if (typeof headers !== "object" || headers === null || Array.isArray(headers)) return projected;
+  for (const [name, value] of Object.entries(headers)) {
+    const validated = validatedResponseHeaderValue(name, value);
+    if (validated !== undefined) projected[name.toLowerCase()] = validated;
+  }
+  return projected;
 }
 
 function sanitizeFields(value: unknown, depth = 0): unknown {
@@ -202,6 +232,35 @@ export function sanitizedJson(value: unknown): string {
   return JSON.stringify(sanitizeForJson(value));
 }
 
+/**
+ * Reserve the budget for newest failures/routing facts before routine observations.
+ * Both classes share one hard bound; a priority flood evicts older priority facts.
+ * Return append order, not priority order or wall-clock order. Oversized records
+ * are skipped so one record cannot prevent smaller, useful facts from fitting.
+ */
+export function retainDiagnosticEvents(
+  events: readonly DiagnosticEvent[],
+  budget: number,
+  sizeOf: (event: DiagnosticEvent) => number = () => 1,
+): readonly DiagnosticEvent[] {
+  const retained = new Set<number>();
+  const sizes = events.map(sizeOf);
+  let used = 0;
+  for (const priority of [true, false]) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      const event = events[index]!;
+      const isPriority = event.level !== "info" || event.category === "routing" ||
+        event.category.startsWith("routing.") || event.category === "logical.provider";
+      if (isPriority !== priority) continue;
+      const size = sizes[index]!;
+      if (size > budget - used) continue;
+      retained.add(index);
+      used += size;
+    }
+  }
+  return events.filter((_event, index) => retained.has(index));
+}
+
 export class DiagnosticLog {
   readonly #events: DiagnosticEvent[] = [];
   readonly #maxEvents: number;
@@ -224,7 +283,9 @@ export class DiagnosticLog {
       for (const event of persisted.slice(-this.#maxEvents)) {
         this.#events.push(Object.freeze({
           ...event,
-          fields: Object.freeze({ ...event.fields }),
+          message: isHeaderDiagnostic(event.category, event.message) ? HEADER_DIAGNOSTIC_MESSAGE : event.message,
+          fields: Object.freeze(isHeaderDiagnostic(event.category, event.message)
+            ? projectResponseHeaders(event.fields) : { ...event.fields }),
         }));
       }
     } catch {
@@ -239,18 +300,22 @@ export class DiagnosticLog {
     fields: Readonly<Record<string, unknown>> = {},
   ): DiagnosticEvent {
     const safeFields: Record<string, string> = {};
-    for (const [key, value] of Object.entries(fields)) {
+    const projectedFields = isHeaderDiagnostic(category, message) ? projectResponseHeaders(fields) : fields;
+    for (const [key, value] of Object.entries(projectedFields)) {
       safeFields[sanitizeDiagnosticText(key)] = sanitizeDiagnosticText(value);
     }
     const event = Object.freeze({
       timestampMs: this.#now(),
       level,
       category: sanitizeDiagnosticText(category),
-      message: sanitizeDiagnosticText(message),
+      message: isHeaderDiagnostic(category, message) ? HEADER_DIAGNOSTIC_MESSAGE : sanitizeDiagnosticText(message),
       fields: Object.freeze(safeFields),
     });
     this.#events.push(event);
-    if (this.#events.length > this.#maxEvents) this.#events.splice(0, this.#events.length - this.#maxEvents);
+    if (this.#events.length > this.#maxEvents) {
+      const retained = retainDiagnosticEvents(this.#events, this.#maxEvents);
+      this.#events.splice(0, this.#events.length, ...retained);
+    }
     try {
       this.#persistence?.append(event);
     } catch {
@@ -273,16 +338,13 @@ export class DiagnosticLog {
   }
 
   recordHeaders(category: string, headers: Readonly<Record<string, unknown>>): DiagnosticEvent {
-    const safeHeaders: Record<string, string> = {};
-    for (const [name, value] of Object.entries(headers)) {
-      safeHeaders[sanitizeDiagnosticText(name)] = sanitizeHeaderValue(name, value);
-    }
-    return this.record("info", category, "Provider response headers observed.", safeHeaders);
+    return this.record("info", category, HEADER_DIAGNOSTIC_MESSAGE, projectResponseHeaders(headers));
   }
 
   recent(limit = 20): readonly DiagnosticEvent[] {
     const safeLimit = Number.isSafeInteger(limit) ? Math.max(0, Math.min(limit, 100)) : 20;
-    return this.#events.slice(-safeLimit).map((event) => ({ ...event, fields: { ...event.fields } }));
+    return retainDiagnosticEvents(this.#events, safeLimit)
+      .map((event) => ({ ...event, fields: { ...event.fields } }));
   }
 
   formatRecent(limit = 20): string {

package/src/host-final-stop-message.ts

@@ -1,124 +1,26 @@
-import {
-	isContextOverflow,
-	isRetryableAssistantError,
-	type AssistantMessage,
-} from "@earendil-works/pi-ai";
-import { sanitizeDiagnosticText } from "./diagnostics.js";
+import { isContextOverflow, isRetryableAssistantError, type AssistantMessage } from "@earendil-works/pi-ai";
 
-/** Fixed fallbacks for a structured provider stop; none matches a host re-dispatch pattern. */
+/** Fixed public reasons: provider prose and unknown reason payloads are never retained. */
 export const REFUSAL_FALLBACK_MESSAGE = "The model refused to complete the request";
-export const UNKNOWN_STOP_FALLBACK_MESSAGE =
-	"Provider stopped with an unrecognized stop reason";
+export const UNKNOWN_STOP_FALLBACK_MESSAGE = "Provider stopped with an unrecognized stop reason";
+// Kept for source compatibility; reasons are now entirely withheld, not reworded.
+export const PARTLY_WITHHELD_MARKER = " (partly withheld)";
 
-/** Upper bound on the normalized stop reason named in a reworded message. */
-const MAX_NAMED_REASON_LENGTH = 64;
-
-/**
- * Whether the pinned host would re-dispatch an error terminal carrying `text`.
- *
- * The host re-dispatches when either retry predicate matches the prose:
- * `AgentSession._isRetryableError` runs pi-ai `isRetryableAssistantError`, and
- * `_checkCompaction` runs `isContextOverflow` before compacting and retrying once
- * (pi-coding-agent dist/core/agent-session.js, both from `@earendil-works/pi-ai`).
- * An unreadable predicate result counts as a match, so the caller keeps looking
- * for a safer form.
- */
-function hostWouldRedispatch(message: AssistantMessage, text: string): boolean {
-	try {
-		const probe = { ...message, errorMessage: text };
-		return isRetryableAssistantError(probe) || isContextOverflow(probe, 0);
-	} catch {
-		return true;
-	}
-}
-
-function namedReasonMessage(reason: string): string {
-	return `Provider stopped (reason: ${reason})`;
-}
-
-/**
- * Normalizes a bounded, sanitized raw stop reason into plain words: every run of
- * non-alphanumeric characters (underscores included) becomes one space, and the
- * result is capped at a word boundary where possible.
- */
-function normalizedReasonWords(rawStopReason: unknown): string[] {
-	if (typeof rawStopReason !== "string") return [];
-	const words = sanitizeDiagnosticText(rawStopReason)
-		.replace(/[^A-Za-z0-9]+/g, " ")
-		.trim()
-		.split(" ")
-		.filter((word) => word.length > 0);
-	const kept: string[] = [];
-	let length = 0;
-	for (const word of words) {
-		const next = length === 0 ? word.length : length + 1 + word.length;
-		if (next > MAX_NAMED_REASON_LENGTH) {
-			if (kept.length === 0) kept.push(word.slice(0, MAX_NAMED_REASON_LENGTH));
-			break;
-		}
-		kept.push(word);
-		length = next;
-	}
-	return kept;
-}
-
-/**
- * Names an unknown stop reason in a message neither host predicate acts on.
- *
- * The first form keeps every normalized word. When that still matches a host
- * predicate (a reason containing "overloaded" or "timeout", say), the second
- * form admits words in order and drops each one whose addition would make the
- * message match. Every admitted prefix was probed, so the result is host-final
- * by construction. An empty result yields `undefined`.
- */
-function unknownStopNamingReason(
-	message: AssistantMessage,
-	rawStopReason: unknown,
-): string | undefined {
-	const words = normalizedReasonWords(rawStopReason);
-	if (words.length === 0) return undefined;
-	const reworded = namedReasonMessage(words.join(" "));
-	if (!hostWouldRedispatch(message, reworded)) return reworded;
-	const kept: string[] = [];
-	for (const word of words) {
-		const tentative = namedReasonMessage([...kept, word].join(" "));
-		if (!hostWouldRedispatch(message, tentative)) kept.push(word);
-	}
-	return kept.length === 0 ? undefined : namedReasonMessage(kept.join(" "));
+/** Probe pinned host predicates without publishing the provider DTO. */
+export function hostWouldRedispatch(message: AssistantMessage, text: string): boolean {
+  try {
+    // Private predicate probe only; this object is never published or retained.
+    const probe = { ...message, errorMessage: text };
+    return isRetryableAssistantError(probe) || isContextOverflow(probe, 0);
+  } catch { return true; }
 }
 
-/**
- * The public error text for a structured refusal or unknown provider stop.
- *
- * The pinned host re-dispatches an error terminal from its prose alone (see
- * `hostWouldRedispatch`). A refusal explanation or stop reason is
- * provider-authored, so text such as "overloaded", "prompt is too long", or
- * "model_context_window_exceeded" would make the host send the stopped request
- * again. The structured code alone selects this path; the provider text is kept
- * only when neither host predicate would act on it. An unknown stop is then
- * reworded so it still names its reason, and only when no reworded form is safe
- * is a fixed fallback published. A refusal whose explanation is unsafe publishes
- * its fixed fallback directly. A message without the structured code, or that is
- * not an error terminal, yields `undefined` and must be published unchanged.
- */
-export function hostFinalStopMessage(
-	message: AssistantMessage,
-): { readonly errorMessage: string } | undefined {
-	const code = (message as { code?: unknown }).code;
-	if (message.stopReason !== "error") return undefined;
-	if (code !== "refusal" && code !== "unknown_stop") return undefined;
-	const candidate = message.errorMessage;
-	if (
-		typeof candidate === "string" &&
-		candidate.length > 0 &&
-		!hostWouldRedispatch(message, candidate)
-	) {
-		return { errorMessage: candidate };
-	}
-	if (code === "refusal") return { errorMessage: REFUSAL_FALLBACK_MESSAGE };
-	return {
-		errorMessage:
-			unknownStopNamingReason(message, message.rawStopReason) ??
-			UNKNOWN_STOP_FALLBACK_MESSAGE,
-	};
+/** A structured stop is an answer, never retry/overflow evidence or a prose retention permission. */
+export function hostFinalStopMessage(message: AssistantMessage): {
+  readonly errorMessage: string;
+  readonly rawStopReason: "refusal" | "unknown_stop";
+} | undefined {
+  const code = Object.getOwnPropertyDescriptor(message, "code")?.value;
+  if (message.stopReason !== "error" || (code !== "refusal" && code !== "unknown_stop")) return undefined;
+  return { errorMessage: code === "refusal" ? REFUSAL_FALLBACK_MESSAGE : UNKNOWN_STOP_FALLBACK_MESSAGE, rawStopReason: code };
 }