agent-accelerator 0.4.0 → 0.5.0

package/src/session/store.ts

@@ -27,9 +27,11 @@ import type { Message, ContentPart } from "../types/message.ts";
 import type { TokenUsage, CacheConfig, ServiceTier } from "../types/core.ts";
 import type { ModelSpec } from "../types/model.ts";
 import type { AgentResponse } from "../types/response.ts";
-import { base64ToBytes } from "../utils/base64.ts";
+import { base64ToBytes, bytesToBase64 } from "../utils/base64.ts";
 import { getModelFromCatalog } from "../models/catalog.ts";
 import type { SubAgentStep } from "../types/response.ts";
+import { SessionLoadError } from "../types/errors.ts";
+import { createSessionId } from "../utils/session.ts";
 
 /** Cumulative per-session token + cost totals (JSON-safe). */
 export interface SessionTotals {
@@ -67,6 +69,8 @@ export interface PersistedAgentSession {
   subagentModel?: string;
   thinkingLevel?: string;
   cache?: CacheConfig;
+  /** Legacy read-only: pre-compact files duplicated base instructions here;
+  * no longer written (`systemPrompt` already embeds them). */
   instructions?: string;
   systemPrompt?: string;
   cachedContentId?: string;
@@ -95,11 +99,13 @@ function specFor(modelStr: string): ReturnType<typeof getModelFromCatalog> {
     if (raw.includes("/")) {
       const [prefix, ...rest] = raw.split("/");
       const id = rest.join("/");
-      return (
-        getModelFromCatalog(prefix!, id) ||
-        getModelFromCatalog(prefix!.toLowerCase(), id) ||
-        getModelFromCatalog(id, id)
-      );
+      const known = getModelFromCatalog(prefix!, id) || getModelFromCatalog(prefix!.toLowerCase(), id);
+      if (known) return known;
+      // A bare-id global search is only meaningful for first-class prefixes: a
+      // custom endpoint's model must not borrow an unrelated model's price.
+      return ["google", "gemini", "openai", "openrouter"].includes(prefix!.toLowerCase())
+        ? getModelFromCatalog(id, id)
+        : undefined;
     }
     return (
       getModelFromCatalog("google", raw) ||
@@ -307,11 +313,24 @@ function snapshotSubagents(traces: Record<string, PersistedSubAgentTrace> | unde
   for (const [id, t] of byId) {
     // Drop assistant step text that merely repeats the final answer: the
     // step marker (turn/type/timestamp) stays, the full text lives on trace.text.
-    const steps = (t.steps ?? []).map((s) =>
-      s.type === "assistant" && typeof s.text === "string" && typeof t.text === "string" && s.text === t.text
-        ? { turn: s.turn, type: s.type, timestamp: s.timestamp }
-        : { ...s }
-    );
+    // Reasoning is never dropped: `thinking`/`thoughtSignature` survive the
+    // dedup so persisted worker steps keep their reasoning traces.
+    const steps = (t.steps ?? []).map((s) => {
+      if (
+        s.type === "assistant" &&
+        typeof s.text === "string" &&
+        typeof t.text === "string" &&
+        s.text === t.text
+      ) {
+        const marker: SubAgentStep = { turn: s.turn, type: s.type, timestamp: s.timestamp };
+        if (typeof s.thinking === "string" && s.thinking) marker.thinking = s.thinking;
+        const sig = (s as { thoughtSignature?: unknown }).thoughtSignature;
+        if (typeof sig === "string" && sig) marker.thoughtSignature = sig;
+        if (typeof s.isError === "boolean") marker.isError = s.isError;
+        return marker;
+      }
+      return { ...s };
+    });
     lean[id] = { ...t, steps };
   }
   try {
@@ -359,6 +378,30 @@ function stripRedundantRawArguments(messages: Message[]): Message[] {
   });
 }
 
+/**
+ * Rewrites binary media (`Uint8Array` / `ArrayBuffer`) as `data:` URLs so the
+ * snapshot survives JSON (a raw `Uint8Array` would serialize as
+ * `{"0":137,"1":80,…}` and corrupt every later turn). Dir mode already moved
+ * bytes to `media/` files, so this is a no-op there.
+ */
+function inlineBinaryMedia(messages: Message[]): Message[] {
+  return messages.map((m) => {
+    if (!Array.isArray(m.content)) return m;
+    let changed = false;
+    const content = (m.content as ContentPart[]).map((part) => {
+      const p = part as unknown as Record<string, unknown>;
+      if (!p || typeof p.type !== "string" || !(MEDIA_PART_KEYS as readonly string[]).includes(p.type)) return part;
+      const value = p[p.type];
+      if (!(value instanceof Uint8Array) && !(value instanceof ArrayBuffer)) return part;
+      changed = true;
+      const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
+      const mime = typeof p.mimeType === "string" && p.mimeType ? p.mimeType : "application/octet-stream";
+      return { ...p, [p.type]: `data:${mime};base64,${bytesToBase64(bytes)}` } as unknown as ContentPart;
+    });
+    return changed ? { ...m, content } : m;
+  });
+}
+
 /** Builds a storable snapshot from a live agent + optional telemetry. */
 export function buildSessionData(agent: SessionAgentLike, telemetry?: SessionTelemetry | SessionTotals | null): PersistedAgentSession {
   const rawModel = agent.modelStringOrSpec as any;
@@ -372,35 +415,109 @@ export function buildSessionData(agent: SessionAgentLike, telemetry?: SessionTel
   const parentSessionId =
     typeof (agent as any)?.parentSessionId === "string" ? (agent as any).parentSessionId as string : undefined;
   const subagents = snapshotSubagents((agent as any)?.subagentTraces as Record<string, PersistedSubAgentTrace> | undefined);
-  const messages = stripRedundantRawArguments(agent.context.messages);
+  const messages = inlineBinaryMedia(stripRedundantRawArguments(agent.context.messages));
+  // `cache.sessionId` echoes the top-level `sessionId` (affinity alias): drop
+  // it from the file when identical so it isn't stored twice. Readers still
+  // accept legacy files carrying it (`importSession`, loop fallbacks).
+  const cacheForFile = (() => {
+    if (!agent.cacheConfig) return undefined;
+    if (agent.cacheConfig.sessionId === agent.sessionId) {
+      const { sessionId: _dropped, ...rest } = agent.cacheConfig;
+      return Object.keys(rest).length > 0 ? rest : undefined;
+    }
+    return agent.cacheConfig;
+  })();
+  // Field order is the on-disk layout contract: identity → config →
+  // systemPrompt → totals → messages → lineage/traces. `instructions` is
+  // intentionally never written: `systemPrompt` already embeds it (plus the
+  // appended directives), so writing both duplicates the same data.
+  // Readers still accept legacy files carrying `instructions`.
   return {
     version: 1,
     sessionId: agent.sessionId,
     model,
     ...(subagentModel ? { subagentModel: String(subagentModel) } : {}),
     ...(agent.thinkingConfig?.level ? { thinkingLevel: agent.thinkingConfig.level as string } : {}),
-    ...(agent.cacheConfig ? { cache: agent.cacheConfig } : {}),
-    ...(agent.instructions ? { instructions: agent.instructions } : {}),
+    ...(cacheForFile ? { cache: cacheForFile } : {}),
     ...(agent.context.systemPrompt ? { systemPrompt: agent.context.systemPrompt } : {}),
     ...(agent.context.cachedContentId ? { cachedContentId: agent.context.cachedContentId } : {}),
-    messages,
     ...(totals ? { totals } : {}),
+    messages,
     ...(parentSessionId ? { parentSessionId } : {}),
     ...(subagents ? { subagents } : {}),
   };
 }
 
-/** Serializes a snapshot to a pretty-printed `.json` document (2-space indent). */
+/**
+ * Serializes a snapshot so every top-level field occupies exactly one line
+ * (`  "key": <compact-json>`), except `messages`: the conversation array
+ * expands with one line per turn (`    {…}`), so each turn stays readable
+ * without exploding nested values vertically. The file stays valid JSON and
+ * greppable. Field order follows `buildSessionData` (totals before messages).
+ */
 export function serializeSession(data: PersistedAgentSession): string {
-  return JSON.stringify({ ...data, version: 1 }, null, 2);
+  const full = { ...data, version: 1 } as Record<string, unknown>;
+  const keys = Object.keys(full).filter((k) => full[k] !== undefined);
+  const lines = ["{"];
+  keys.forEach((k, i) => {
+    const comma = i < keys.length - 1 ? "," : "";
+    if (k === "messages" && Array.isArray(full[k])) {
+      const turns = full[k] as unknown[];
+      if (turns.length === 0) {
+        lines.push(`  ${JSON.stringify(k)}: []${comma}`);
+      } else {
+        lines.push(`  ${JSON.stringify(k)}: [`);
+        turns.forEach((t, j) => {
+          lines.push(`    ${JSON.stringify(t)}${j < turns.length - 1 ? "," : ""}`);
+        });
+        lines.push(`  ]${comma}`);
+      }
+      return;
+    }
+    lines.push(`  ${JSON.stringify(k)}: ${JSON.stringify(full[k])}${comma}`);
+  });
+  lines.push("}");
+  return lines.join("\n");
 }
 
-/** Parses new pretty `.session.json` snapshots AND legacy `.session.jsonl` documents. */
-export function deserializeSession(raw: string): PersistedAgentSession | null {
+const MESSAGE_ROLES = new Set(["system", "user", "assistant", "tool"]);
+
+/**
+ * Index of the first structurally invalid message, or -1. A loaded snapshot
+ * is untrusted input: provider history builders assume `role` + `content`
+ * shapes, so a hand-edited or tampered file must fail at load, not as a
+ * TypeError deep inside a request.
+ */
+export function findInvalidMessage(messages: unknown): number {
+  if (!Array.isArray(messages)) return 0;
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i] as { role?: unknown; content?: unknown } | null;
+    if (!m || typeof m !== "object" || typeof m.role !== "string" || !MESSAGE_ROLES.has(m.role)) return i;
+    if (typeof m.content === "string") continue;
+    if (!Array.isArray(m.content)) return i;
+    for (const part of m.content) {
+      if (!part || typeof part !== "object" || typeof (part as { type?: unknown }).type !== "string") return i;
+    }
+  }
+  return -1;
+}
+
+/** Load limits for session snapshots (see {@link MAX_SESSION_MESSAGES} / {@link MAX_SESSION_JSON_BYTES}). */
+export interface SessionLimits {
+  maxMessages?: number;
+  maxBytes?: number;
+}
+
+/** Marker for a structurally valid payload that exceeds the configured limits. */
+const OVER_LIMIT = Symbol("session-over-limit");
+
+function parseSession(raw: string, limits?: SessionLimits): PersistedAgentSession | null | typeof OVER_LIMIT {
+  const maxMessages = limits?.maxMessages ?? MAX_SESSION_MESSAGES;
+  const maxBytes = limits?.maxBytes ?? MAX_SESSION_JSON_BYTES;
   const text = (raw ?? "").trim();
   if (!text) return null;
-  // Q-10: reject oversized payloads (>10MB JSON) — return null, no console.
-  if (text.length > MAX_SESSION_JSON_BYTES) return null;
+  // Q-10: oversized payloads are rejected, but flagged as over-limit (NOT corrupt).
+  if (text.length > maxBytes) return OVER_LIMIT;
   try {
     // Legacy JSONL: lines shaped {type: session|mainModel|subagentModel|metrics|message|...}
     if (text.startsWith('{"type"')) {
@@ -453,11 +570,11 @@ export function deserializeSession(raw: string): PersistedAgentSession | null {
         }
       }
       if (!sessionId && messages.length === 0) return null;
-      // Q-10: oversize guard — return null, no console.
-      if (messages.length > MAX_SESSION_MESSAGES) return null;
+      // Q-10: oversize guard — flagged as over-limit, not corrupt.
+      if (messages.length > maxMessages) return OVER_LIMIT;
       return {
         version: 1,
-        sessionId: sessionId || `accel-${Date.now()}`,
+        sessionId: sessionId || createSessionId(),
         model,
         ...(subagentModel ? { subagentModel } : {}),
         ...(thinkingLevel ? { thinkingLevel } : {}),
@@ -478,10 +595,10 @@ export function deserializeSession(raw: string): PersistedAgentSession | null {
     if ("version" in obj && (obj as { version?: unknown }).version !== 1) return null;
     // Very old single-JSON shape without version: {sessionId, model, context:{messages}}
     if (obj.context && Array.isArray(obj.context.messages) && !Array.isArray(obj.messages)) {
-      if ((obj.context.messages as unknown[]).length > MAX_SESSION_MESSAGES) return null;
+      if ((obj.context.messages as unknown[]).length > maxMessages) return OVER_LIMIT;
       return {
         version: 1,
-        sessionId: obj.sessionId ?? obj.id ?? `accel-${Date.now()}`,
+        sessionId: obj.sessionId ?? obj.id ?? createSessionId(),
         model: obj.model ?? "",
         subagentModel: obj.subagentModel,
         thinkingLevel: obj.thinkingLevel ?? obj.thinkingLevelChange,
@@ -496,12 +613,12 @@ export function deserializeSession(raw: string): PersistedAgentSession | null {
       };
     }
     if (!obj.sessionId && !Array.isArray(obj.messages)) return null;
-    if (Array.isArray(obj.messages) && (obj.messages as unknown[]).length > MAX_SESSION_MESSAGES) return null;
+    if (Array.isArray(obj.messages) && (obj.messages as unknown[]).length > maxMessages) return OVER_LIMIT;
     if ("sessionId" in obj && obj.sessionId !== undefined && typeof obj.sessionId !== "string") return null;
     if ("messages" in obj && obj.messages !== undefined && !Array.isArray(obj.messages)) return null;
     return {
       version: 1,
-      sessionId: obj.sessionId ?? `accel-${Date.now()}`,
+      sessionId: obj.sessionId ?? createSessionId(),
       model: obj.model ?? "",
       subagentModel: obj.subagentModel,
       thinkingLevel: obj.thinkingLevel,
@@ -519,15 +636,59 @@ export function deserializeSession(raw: string): PersistedAgentSession | null {
   }
 }
 
+/** Parses new pretty `.session.json` snapshots AND legacy `.session.jsonl` documents. Returns null for empty, corrupt or over-limit input. */
+export function deserializeSession(raw: string, limits?: SessionLimits): PersistedAgentSession | null {
+  const parsed = parseSession(raw, limits);
+  if (parsed === OVER_LIMIT || parsed === null) return null;
+  return findInvalidMessage(parsed.messages) === -1 ? parsed : null;
+}
+
+/** Outcome of {@link inspectSessionPayload}. */
+export type SessionPayloadStatus = "ok" | "empty" | "corrupt" | "over_limit";
+
+/**
+ * Like {@link deserializeSession} but says WHY a payload did not load. A
+ * valid snapshot that merely exceeds the load limits is `over_limit`, never
+ * `corrupt`, so persistence never quarantines (or loops on) healthy data.
+ */
+export function inspectSessionPayload(
+  raw: string,
+  limits?: SessionLimits
+): { status: SessionPayloadStatus; session?: PersistedAgentSession } {
+  if (!(raw ?? "").trim()) return { status: "empty" };
+  const parsed = parseSession(raw, limits);
+  if (parsed === OVER_LIMIT) return { status: "over_limit" };
+  if (parsed === null || findInvalidMessage(parsed.messages) !== -1) return { status: "corrupt" };
+  return { status: "ok", session: parsed };
+}
+
 /** Loads a session file (pretty `.json` or legacy `.jsonl`). Returns null when missing/corrupt. */
-export function loadSessionFile(filePath: string): PersistedAgentSession | null {
+export function loadSessionFile(filePath: string, limits?: SessionLimits): PersistedAgentSession | null {
+  const resolved = path.resolve(filePath);
+  let raw: string;
   try {
-    const resolved = path.resolve(filePath);
     if (!fs.existsSync(resolved)) return null;
-    return deserializeSession(fs.readFileSync(resolved, "utf8"));
+    raw = fs.readFileSync(resolved, "utf8");
   } catch {
     return null;
   }
+  return sessionFromPayload(raw, resolved, limits);
+}
+
+/**
+ * Shared load tail: corrupt/empty -> null (callers start fresh), but a valid
+ * over-limit snapshot throws so the app cannot silently start blank and then
+ * overwrite a healthy long-running session.
+ */
+function sessionFromPayload(raw: string, file: string, limits?: SessionLimits): PersistedAgentSession | null {
+  const res = inspectSessionPayload(raw, limits);
+  if (res.status === "over_limit") {
+    throw new SessionLoadError(
+      `[Agent Accelerator] Session "${file}" exceeds the load limits (maxMessages ${limits?.maxMessages ?? MAX_SESSION_MESSAGES}, maxBytes ${limits?.maxBytes ?? MAX_SESSION_JSON_BYTES}). Raise them via the limits argument or archive the file; it was NOT modified.`,
+      { file }
+    );
+  }
+  return res.session ?? null;
 }
 
 /** Atomic file write (temp + rename) so a crash never leaves half-written JSON. */
@@ -570,7 +731,9 @@ export function saveSessionFile(
     if (fs.existsSync(resolved)) {
       try {
         const raw = fs.readFileSync(resolved, "utf8");
-        if (raw.trim().length > 0 && deserializeSession(raw) === null) {
+        // Only genuinely corrupt payloads are quarantined; a healthy snapshot
+        // over the load limits is simply rewritten (it is our own prior save).
+        if (inspectSessionPayload(raw).status === "corrupt") {
           try { fs.renameSync(resolved, `${resolved}.corrupt-${Date.now()}`); } catch {}
         }
       } catch {}
@@ -790,7 +953,7 @@ export function saveSessionDir(
       if (fs.existsSync(target)) {
         try {
           const raw = fs.readFileSync(target, "utf8");
-          if (raw.trim().length > 0 && deserializeSession(raw) === null) {
+          if (inspectSessionPayload(raw).status === "corrupt") {
             try { fs.renameSync(target, `${target}.corrupt-${Date.now()}`); } catch {}
           }
         } catch {}
@@ -814,14 +977,14 @@ export interface LoadedSessionDir {
  * single files). Relative `media/…` refs resolve against the folder.
  * Returns null when nothing loadable exists.
  */
-export function loadSessionDir(sessionPath: string): LoadedSessionDir | null {
+export function loadSessionDir(sessionPath: string, limits?: SessionLimits): LoadedSessionDir | null {
   try {
     const resolved = path.resolve(sessionPath);
     let dir = resolved;
     try {
       const st = fs.statSync(resolved);
       if (st.isFile()) {
-        const single = loadSessionFile(resolved);
+        const single = loadSessionFile(resolved, limits);
         if (!single) return null;
         dir = path.dirname(resolved);
         if (single.messages) {
@@ -834,11 +997,12 @@ export function loadSessionDir(sessionPath: string): LoadedSessionDir | null {
     }
     const file = path.join(dir, "session.json");
     if (!fs.existsSync(file)) return null;
-    const data = deserializeSession(fs.readFileSync(file, "utf8"));
+    const data = sessionFromPayload(fs.readFileSync(file, "utf8"), file, limits);
     if (!data) return null;
     data.messages = resolveMediaPaths(data.messages, dir);
     return { session: data, dir };
-  } catch {
+  } catch (err) {
+    if (err instanceof SessionLoadError) throw err;
     return null;
   }
 }
@@ -870,10 +1034,10 @@ export function findLatestSessionDir(rootDir: string): string | null {
 // size/version guards, no behavior change otherwise).
 // ---------------------------------------------------------------------------
 
-/** Max messages accepted in a session snapshot (Q-10). */
-export const MAX_SESSION_MESSAGES = 5000;
-/** Max raw JSON bytes accepted in deserializeSession (Q-10). */
-export const MAX_SESSION_JSON_BYTES = 10 * 1024 * 1024;
+/** Default max messages accepted when loading a session snapshot (override via `SessionLimits`). */
+export const MAX_SESSION_MESSAGES = 50_000;
+/** Default max raw JSON size accepted when loading a session snapshot (override via `SessionLimits`). */
+export const MAX_SESSION_JSON_BYTES = 100 * 1024 * 1024;
 
 function sessionLoadError(message: string): Error {
   const e = new Error(`[Agent Accelerator] Invalid session: ${message}`);
@@ -936,70 +1100,13 @@ export function getSessionContextWindowOrUndefined(modelStr: string): number | u
 }
 
 // ---------------------------------------------------------------------------
-// Q-41: telemetry bus (no console.* in library code).
+// Q-41: telemetry bus lives in `../telemetry.ts` (dependency-free, so low-level
+// modules such as the catalog cache and event stream can emit without import
+// cycles). Re-exported here for backward compatibility.
 // ---------------------------------------------------------------------------
-
-/** Telemetry event emitted via the in-process bus (Q-41). */
-export interface TelemetryEvent {
-  code: string;
-  message: string;
-  level?: "info" | "warn" | "error";
-  data?: unknown;
-  timestamp: number;
-}
-
-/** Listener subscribed via `telemetryBus.onEvent`. */
-export type TelemetryListener = (event: TelemetryEvent) => void;
-
-interface TelemetryBus {
-  /** Subscribes to telemetry events. Returns an unsubscribe function. Default: no-op delivery (no listeners, no console). */
-  onEvent(listener: TelemetryListener): () => void;
-  /** Emits a warning (level `warn`). Never throws, never logs to console. */
-  emitWarning(code: string, message: string, data?: unknown): void;
-  /** Emits a generic event. Never throws, never logs to console. */
-  emit(event: Omit<TelemetryEvent, "timestamp"> & { timestamp?: number }): void;
-  /** Removes all listeners (useful in tests). */
-  clear(): void;
-}
-
-/**
- * In-process telemetry bus (Q-41). Library code routes warnings/anomalies
- * here instead of `console.*`. Default has zero listeners so emission is a
- * no-op; CLIs/tests attach a pretty logger via `onEvent`.
- */
-export const telemetryBus: TelemetryBus = (() => {
-  const listeners = new Set<TelemetryListener>();
-  const deliver = (event: TelemetryEvent): void => {
-    for (const l of [...listeners]) {
-      try { l(event); } catch {
-        // why: a faulty telemetry listener must not break the emitting run.
-      }
-    }
-  };
-  return {
-    onEvent(listener: TelemetryListener): () => void {
-      listeners.add(listener);
-      return () => { listeners.delete(listener); };
-    },
-    emitWarning(code: string, message: string, data?: unknown): void {
-      try {
-        deliver({ code, message, level: "warn", data, timestamp: Date.now() });
-      } catch {
-        // why: telemetry emission is observability-only.
-      }
-    },
-    emit(event: Omit<TelemetryEvent, "timestamp"> & { timestamp?: number }): void {
-      try {
-        deliver({ level: "info", ...event, timestamp: event.timestamp ?? Date.now() });
-      } catch {
-        // why: telemetry emission is observability-only.
-      }
-    },
-    clear(): void {
-      listeners.clear();
-    },
-  };
-})();
+import { telemetryBus } from "../telemetry.ts";
+export { telemetryBus };
+export type { TelemetryEvent, TelemetryListener } from "../telemetry.ts";
 
 /** Reports a usage/cost anomaly via the global hook + telemetry bus (Q-35). Never logs. */
 export function reportUsageAnomaly(detail: { type: string; [k: string]: unknown }): void {
@@ -1098,19 +1205,28 @@ export type PricedCost = NonNullable<TokenUsage["cost"]> & {
 };
 
 /**
- * Service-tier price multipliers (Q-36). ESTIMATES, not vendor guarantees:
- * `flex` batches trade latency for ~0.5x price, `priority` reserves capacity
- * at ~1.5x. Standard/default is 1.0. Documented as estimates because vendors
- * do not publish exact tier multipliers in the catalog.
+ * Service-tier price multipliers (Q-36). Aligned with pi
+ * (`api/openai-responses.ts:387`): `flex` trades latency for ~0.5x price,
+ * `priority`/`fast` reserve capacity at ~2x (`2.5x` for `gpt-5.5`).
+ * Standard/default is 1.0. Estimates because vendors do not publish exact
+ * tier multipliers in the catalog.
  */
 const SERVICE_TIER_MULTIPLIERS: Record<string, number> = {
   flex: 0.5,
-  priority: 1.5,
+  priority: 2,
+  fast: 2,
 };
 
-function serviceTierMultiplier(serviceTier?: string): { multiplier: number; tier?: string } {
+function serviceTierMultiplier(serviceTier?: string, modelId?: string): { multiplier: number; tier?: string } {
   if (!serviceTier) return { multiplier: 1 };
-  const m = SERVICE_TIER_MULTIPLIERS[serviceTier.toLowerCase()];
+  const lower = serviceTier.toLowerCase();
+  if (lower === "priority" || lower === "fast") {
+    if (typeof modelId === "string" && modelId.includes("gpt-5.5")) {
+      return { multiplier: 2.5, tier: serviceTier };
+    }
+    return { multiplier: 2, tier: serviceTier };
+  }
+  const m = SERVICE_TIER_MULTIPLIERS[lower];
   return m !== undefined ? { multiplier: m, tier: serviceTier } : { multiplier: 1, tier: serviceTier };
 }
 
@@ -1190,7 +1306,7 @@ function resolveEffectivePricing(
 export function priceUsage(
   usage: TokenUsage,
   spec?: ModelSpec,
-  opts?: { serviceTier?: ServiceTier | string }
+  opts?: { serviceTier?: ServiceTier | string; modelId?: string }
 ): PricedCost | undefined {
   const reported = usage?.cost;
   if (reported && typeof reported.totalCost === "number" && reported.totalCost > 0) {
@@ -1233,7 +1349,7 @@ export function priceUsage(
   if (!pricing.input && !pricing.output && !pricing.cacheRead && !pricing.cacheWrite && !pricing.audio) {
     return undefined;
   }
-  const { multiplier, tier: serviceTier } = serviceTierMultiplier(opts?.serviceTier);
+  const { multiplier, tier: serviceTier } = serviceTierMultiplier(opts?.serviceTier, opts?.modelId ?? spec?.id);
   const nonCachedInput = Math.max(0, inputTokens - cachedTokens);
   // Integer micro-USD accumulation: microUSD = tokens * pricePerMillion
   // ($P per 1M tokens == $P/1e6 per token == P micro-USD per token).

package/src/streaming/event-stream.ts

@@ -1,4 +1,5 @@
 import type { StreamEvent, AgentResponse } from "../types/response.ts";
+import { telemetryBus } from "../telemetry.ts";
 
 /** Listener invoked for a matching stream event type or `*`. */
 export type StreamEventListener = (event: StreamEvent) => void;
@@ -36,9 +37,10 @@ function approxEventBytes(event: StreamEvent): number {
   return n;
 }
 
-function reportStreamAnomaly(detail: unknown): void {
-  // why: telemetry hook only, never console — streams are hot paths and
-  // logging per-drop would spam and break no-console policy (Q-29/Q-41).
+function reportStreamAnomaly(detail: { type: string; [k: string]: unknown }): void {
+  // why: bus + hook only, never console — streams are hot paths and logging
+  // per-drop would spam and break no-console policy (Q-29/Q-41).
+  telemetryBus.emitWarning(detail.type, `[Agent Accelerator] stream anomaly: ${detail.type}`, detail);
   try {
     (globalThis as unknown as { __agentAccelAnomaly?: (d: unknown) => void }).__agentAccelAnomaly?.(detail);
   } catch {
@@ -256,7 +258,7 @@ export class AssistantMessageEventStream implements AsyncIterable<StreamEvent> {
     this.cancelHandlers.clear();
     const err = reason instanceof Error ? reason : null;
     const abortErr: Error =
-      err && (err.name === "AbortError" || /abort|cancel/i.test(err.message))
+      err && err.name === "AbortError"
         ? err
         : Object.assign(new Error("Stream aborted"), { name: "AbortError" });
     this.fail(abortErr);

package/src/telemetry-file.ts

@@ -0,0 +1,31 @@
+/**
+ * Opt-in disk sink for the telemetry bus (`AgentConfig.telemetry.persist`).
+ * Appends one JSON line per event to `<home>/telemetry/<YYYY-MM-DD>.ndjson`.
+ * Each event is a single synchronous append, so a process crash keeps every
+ * event already emitted: a `tool.call_started` with no ending event was in
+ * flight, and the last `tool.progress` shows how far it got. Power loss is not
+ * covered (no fsync). `turn.thinking` (full reasoning text) is never written.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { telemetryBus } from "./telemetry.ts";
+import { safeStringify } from "./utils/serialization.ts";
+
+const sinks = new Set<string>();
+
+/** Starts appending bus events under `home` (idempotent per folder). */
+export function persistTelemetry(home: string): void {
+  const dir = path.join(home, "telemetry");
+  if (sinks.has(dir)) return;
+  sinks.add(dir);
+  telemetryBus.onEvent((event) => {
+    if (event.code === "turn.thinking") return;
+    try {
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+      const file = path.join(dir, `${new Date(event.timestamp).toISOString().slice(0, 10)}.ndjson`);
+      fs.appendFileSync(file, safeStringify(event) + "\n", { mode: 0o600 });
+    } catch {
+      // why: a full disk must never fail a run, and reporting it would re-enter this listener.
+    }
+  });
+}

package/src/telemetry.ts

@@ -0,0 +1,65 @@
+/**
+ * In-process telemetry bus (Q-41). Library code routes warnings, anomalies and
+ * per-turn traces here instead of `console.*`. The default has zero listeners,
+ * so emission is a no-op; CLIs, tests and observability layers attach with
+ * `telemetryBus.onEvent`. Intentionally dependency-free: every module in the
+ * SDK (providers, catalog cache, event stream, loop, session store) may import
+ * it without creating an import cycle.
+ */
+
+/** Telemetry event emitted via the in-process bus (Q-41). */
+export interface TelemetryEvent {
+  code: string;
+  message: string;
+  level?: "info" | "warn" | "error";
+  data?: unknown;
+  timestamp: number;
+}
+
+/** Listener subscribed via `telemetryBus.onEvent`. */
+export type TelemetryListener = (event: TelemetryEvent) => void;
+
+interface TelemetryBus {
+  /** Subscribes to telemetry events. Returns an unsubscribe function. Default: no-op delivery (no listeners, no console). */
+  onEvent(listener: TelemetryListener): () => void;
+  /** Emits a warning (level `warn`). Never throws, never logs to console. */
+  emitWarning(code: string, message: string, data?: unknown): void;
+  /** Emits a generic event. Never throws, never logs to console. */
+  emit(event: Omit<TelemetryEvent, "timestamp"> & { timestamp?: number }): void;
+  /** Removes all listeners (useful in tests). */
+  clear(): void;
+}
+
+export const telemetryBus: TelemetryBus = (() => {
+  const listeners = new Set<TelemetryListener>();
+  const deliver = (event: TelemetryEvent): void => {
+    for (const l of [...listeners]) {
+      try { l(event); } catch {
+        // why: a faulty telemetry listener must not break the emitting run.
+      }
+    }
+  };
+  return {
+    onEvent(listener: TelemetryListener): () => void {
+      listeners.add(listener);
+      return () => { listeners.delete(listener); };
+    },
+    emitWarning(code: string, message: string, data?: unknown): void {
+      try {
+        deliver({ code, message, level: "warn", data, timestamp: Date.now() });
+      } catch {
+        // why: telemetry emission is observability-only.
+      }
+    },
+    emit(event: Omit<TelemetryEvent, "timestamp"> & { timestamp?: number }): void {
+      try {
+        deliver({ level: "info", ...event, timestamp: event.timestamp ?? Date.now() });
+      } catch {
+        // why: telemetry emission is observability-only.
+      }
+    },
+    clear(): void {
+      listeners.clear();
+    },
+  };
+})();