whale-code 6.5.6 → 6.5.7

package/dist/shared/agent-core-pricing.test.js

@@ -0,0 +1,191 @@
+import { describe, it, expect } from "vitest";
+import { estimateCostUsd, MODEL_PRICING, emitCostWarningIfNeeded, djb2Hash } from "./agent-core.js";
+
+// ============================================================================
+// estimateCostUsd
+// ============================================================================
+
+describe("estimateCostUsd", () => {
+  it("calculates cost for claude-opus-4-6", () => {
+    // 1M input tokens at $5/M + 1M output tokens at $25/M = $30
+    const cost = estimateCostUsd(1_000_000, 1_000_000, "claude-opus-4-6");
+    expect(cost).toBeCloseTo(30.0);
+  });
+  it("calculates cost for claude-sonnet-4-6", () => {
+    // 1M input at $3/M + 1M output at $15/M = $18
+    const cost = estimateCostUsd(1_000_000, 1_000_000, "claude-sonnet-4-6");
+    expect(cost).toBeCloseTo(18.0);
+  });
+  it("calculates cost for claude-haiku-4-5", () => {
+    // 1M input at $1/M + 1M output at $5/M = $6
+    const cost = estimateCostUsd(1_000_000, 1_000_000, "claude-haiku-4-5");
+    expect(cost).toBeCloseTo(6.0);
+  });
+  it("includes thinking tokens in cost", () => {
+    // Opus: 0 input + 0 output + 1M thinking at $25/M = $25
+    const cost = estimateCostUsd(0, 0, "claude-opus-4-6", 1_000_000);
+    expect(cost).toBeCloseTo(25.0);
+  });
+  it("handles zero tokens", () => {
+    expect(estimateCostUsd(0, 0, "claude-opus-4-6")).toBe(0);
+  });
+  it("falls back to sonnet pricing for unknown models", () => {
+    // Unknown model falls back to sonnet pricing: 1M input at $3/M + 1M output at $15/M
+    const cost = estimateCostUsd(1_000_000, 1_000_000, "claude-unknown-model");
+    expect(cost).toBeCloseTo(18.0);
+  });
+  it("handles partial model name matching", () => {
+    // "claude-opus-4-6" is contained in "claude-opus-4-6-20260101"
+    const cost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6-20260101");
+    // model.includes(k) checks if the passed model includes the pricing key: $5/M input
+    expect(cost).toBeCloseTo(5.0);
+  });
+  it("calculates fractional token costs correctly", () => {
+    // 500 input tokens for opus: 500/1M * $5 = $0.0025
+    const cost = estimateCostUsd(500, 0, "claude-opus-4-6");
+    expect(cost).toBeCloseTo(0.0025);
+  });
+
+  // ---------- Cache-aware pricing ----------
+
+  it("applies Anthropic 90% cache read discount", () => {
+    // Opus: 1M input at $5/M = $5, but 500K are cache reads -> save 500K/1M * $5 * 0.9 = $2.25
+    const cost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6", 0, 500_000, 0);
+    expect(cost).toBeCloseTo(5.0 - 2.25); // $2.75
+  });
+  it("applies Anthropic 25% cache creation surcharge", () => {
+    // Opus: 1M input at $5/M = $5 + 200K creation -> 200K/1M * $5 * 0.25 = $0.25
+    const cost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6", 0, 0, 200_000);
+    expect(cost).toBeCloseTo(5.25);
+  });
+  it("applies both Anthropic cache read and creation adjustments", () => {
+    // Opus: 1M input at $5/M = $5
+    // 800K cache reads -> save 800K/1M * $5 * 0.9 = $3.60
+    // 100K cache creation -> add 100K/1M * $5 * 0.25 = $0.125
+    // Total: $5 - $3.60 + $0.125 = $1.525
+    const cost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6", 0, 800_000, 100_000);
+    expect(cost).toBeCloseTo(1.525);
+  });
+  it("applies OpenAI 50% cache read discount", () => {
+    // Unknown OpenAI model falls back to sonnet pricing ($3/M input)
+    const baseCost = estimateCostUsd(1_000_000, 0, "gpt-5");
+    const cachedCost = estimateCostUsd(1_000_000, 0, "gpt-5", 0, 500_000, 0);
+    expect(cachedCost).toBeLessThan(baseCost);
+    const savings = baseCost - cachedCost;
+    const expectedSavings = 500_000 / 1_000_000 * MODEL_PRICING["claude-sonnet-4-6"].input * 0.5;
+    expect(savings).toBeCloseTo(expectedSavings);
+  });
+  it("applies Gemini 75% cache read discount", () => {
+    const baseCost = estimateCostUsd(1_000_000, 0, "gemini-3-pro-preview");
+    const cachedCost = estimateCostUsd(1_000_000, 0, "gemini-3-pro-preview", 0, 500_000, 0);
+    expect(cachedCost).toBeLessThan(baseCost);
+    const savings = baseCost - cachedCost;
+    const expectedSavings = 500_000 / 1_000_000 * MODEL_PRICING["claude-sonnet-4-6"].input * 0.75;
+    expect(savings).toBeCloseTo(expectedSavings);
+  });
+  it("does not apply cache discount when cache tokens are zero", () => {
+    const noCacheCost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6");
+    const zeroCacheCost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6", 0, 0, 0);
+    expect(zeroCacheCost).toBe(noCacheCost);
+  });
+  it("applies Bedrock cache pricing same as Anthropic", () => {
+    // Bedrock uses same 90% cache read discount
+    const baseCost = estimateCostUsd(1_000_000, 0, "us.anthropic.claude-sonnet-4-6-v1:0");
+    const cachedCost = estimateCostUsd(1_000_000, 0, "us.anthropic.claude-sonnet-4-6-v1:0", 0, 500_000, 0);
+    expect(cachedCost).toBeLessThan(baseCost);
+  });
+});
+
+// ============================================================================
+// MODEL_PRICING
+// ============================================================================
+
+describe("MODEL_PRICING", () => {
+  it("has pricing for all three expected models", () => {
+    expect(MODEL_PRICING).toHaveProperty("claude-sonnet-4-6");
+    expect(MODEL_PRICING).toHaveProperty("claude-opus-4-6");
+    expect(MODEL_PRICING).toHaveProperty("claude-haiku-4-5");
+  });
+  it("has entries for multiple models", () => {
+    expect(Object.keys(MODEL_PRICING).length).toBeGreaterThanOrEqual(3);
+  });
+  it("opus is more expensive than sonnet", () => {
+    expect(MODEL_PRICING["claude-opus-4-6"].input).toBeGreaterThan(MODEL_PRICING["claude-sonnet-4-6"].input);
+    expect(MODEL_PRICING["claude-opus-4-6"].output).toBeGreaterThan(MODEL_PRICING["claude-sonnet-4-6"].output);
+  });
+  it("sonnet is more expensive than haiku", () => {
+    expect(MODEL_PRICING["claude-sonnet-4-6"].input).toBeGreaterThan(MODEL_PRICING["claude-haiku-4-5"].input);
+  });
+  it("Claude 4.x models have thinking pricing", () => {
+    for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
+      if (key.startsWith("claude-") && !key.includes("3-5-") && !key.includes("3-haiku")) {
+        expect(pricing.thinking).toBeDefined();
+        expect(pricing.thinking).toBeGreaterThan(0);
+      }
+    }
+  });
+  it("thinking rate matches output rate for Claude 4.x models", () => {
+    for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
+      if (key.startsWith("claude-") && !key.includes("3-5-") && !key.includes("3-haiku")) {
+        expect(pricing.thinking).toBe(pricing.output);
+      }
+    }
+  });
+});
+
+// ============================================================================
+// emitCostWarningIfNeeded
+// ============================================================================
+
+describe("emitCostWarningIfNeeded", () => {
+  it("emits at 25% threshold", () => {
+    const warnings = new Set();
+    const texts = [];
+    emitCostWarningIfNeeded(1.3, 5.0, warnings, t => texts.push(t));
+    expect(warnings.has(25)).toBe(true);
+    expect(texts).toHaveLength(1);
+    expect(texts[0]).toContain("25%");
+  });
+  it("emits all 3 thresholds at once when cost is high", () => {
+    const warnings = new Set();
+    const texts = [];
+    emitCostWarningIfNeeded(4.0, 5.0, warnings, t => texts.push(t));
+    expect(warnings.size).toBe(3);
+    expect(texts).toHaveLength(3);
+  });
+  it("is idempotent -- does not re-emit already-emitted warnings", () => {
+    const warnings = new Set([25]);
+    const texts = [];
+    emitCostWarningIfNeeded(1.5, 5.0, warnings, t => texts.push(t));
+    expect(texts).toHaveLength(0);
+  });
+  it("does nothing when maxCostUsd is Infinity", () => {
+    const warnings = new Set();
+    const texts = [];
+    emitCostWarningIfNeeded(100, Infinity, warnings, t => texts.push(t));
+    expect(texts).toHaveLength(0);
+  });
+  it("includes 'Wrap up soon.' only at 75%", () => {
+    const warnings = new Set();
+    const texts = [];
+    emitCostWarningIfNeeded(4.0, 5.0, warnings, t => texts.push(t));
+    // 25% and 50% should NOT contain "Wrap up"
+    expect(texts[0]).not.toContain("Wrap up");
+    expect(texts[1]).not.toContain("Wrap up");
+    // 75% SHOULD contain "Wrap up"
+    expect(texts[2]).toContain("Wrap up soon.");
+  });
+});
+
+// ============================================================================
+// djb2Hash
+// ============================================================================
+
+describe("djb2Hash", () => {
+  it("is deterministic", () => {
+    expect(djb2Hash("hello world")).toBe(djb2Hash("hello world"));
+  });
+  it("produces different hashes for different inputs", () => {
+    expect(djb2Hash("input-a")).not.toBe(djb2Hash("input-b"));
+  });
+});

package/dist/shared/agent-core-sanitize-retry.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect } from "vitest";
+import { sanitizeError, isRetryableError } from "./agent-core.js";
+
+// ============================================================================
+// sanitizeError
+// ============================================================================
+
+describe("sanitizeError", () => {
+  it("strips API keys starting with sk-", () => {
+    const err = "Error: invalid key sk-abcdef1234567890abcdef";
+    const result = sanitizeError(err);
+    expect(result).not.toContain("abcdef1234567890");
+    expect(result).toContain("sk-***");
+  });
+  it("strips key=value patterns", () => {
+    const err = "Error: key=abcdefghijklmnopqrstuvwxyz";
+    const result = sanitizeError(err);
+    expect(result).toContain("key=***");
+    expect(result).not.toContain("abcdefghijklmnopqrstuvwxyz");
+  });
+  it("strips password patterns", () => {
+    const err = "Error: password=mysecretpassword123";
+    const result = sanitizeError(err);
+    expect(result).toContain("password=***");
+    expect(result).not.toContain("mysecretpassword123");
+  });
+  it("strips stack traces (lines starting with at)", () => {
+    const err = "Error: something failed\n    at Object.<anonymous> (/foo/bar.js:10:15)\n    at Module._compile (internal/modules/cjs/loader.js:999:30)";
+    const result = sanitizeError(err);
+    expect(result).not.toContain("at Object.<anonymous>");
+    expect(result).not.toContain("at Module._compile");
+    expect(result).toContain("Error: something failed");
+  });
+  it("truncates to 500 characters", () => {
+    const err = "x".repeat(1000);
+    const result = sanitizeError(err);
+    expect(result.length).toBeLessThanOrEqual(500);
+  });
+  it("handles non-string errors", () => {
+    const result = sanitizeError({
+      code: 500,
+      message: "server error"
+    });
+    expect(result).toContain("object");
+  });
+  it("handles null/undefined", () => {
+    expect(sanitizeError(null)).toBe("null");
+    expect(sanitizeError(undefined)).toBe("undefined");
+  });
+  it("strips key: value patterns with colon separator", () => {
+    const err = "Error: key: abcdefghijklmnopqrstuvwxyz";
+    const result = sanitizeError(err);
+    expect(result).toContain("key=***");
+  });
+  it("strips password: value patterns with colon separator", () => {
+    const err = 'Config: password: "mysecret123"';
+    const result = sanitizeError(err);
+    expect(result).toContain("password=***");
+  });
+});
+
+// ============================================================================
+// isRetryableError
+// ============================================================================
+
+describe("isRetryableError", () => {
+  it("returns true for status 429 (rate limit)", () => {
+    expect(isRetryableError({
+      status: 429
+    })).toBe(true);
+  });
+  it("returns true for status 500 (server error)", () => {
+    expect(isRetryableError({
+      status: 500
+    })).toBe(true);
+  });
+  it("returns true for status 529 (overloaded)", () => {
+    expect(isRetryableError({
+      status: 529
+    })).toBe(true);
+  });
+  it("returns false for status 400 (bad request)", () => {
+    expect(isRetryableError({
+      status: 400
+    })).toBe(false);
+  });
+  it("returns false for status 401 (unauthorized)", () => {
+    expect(isRetryableError({
+      status: 401
+    })).toBe(false);
+  });
+  it("returns false for status 404 (not found)", () => {
+    expect(isRetryableError({
+      status: 404
+    })).toBe(false);
+  });
+  it("returns true for overloaded message", () => {
+    expect(isRetryableError({
+      message: "API is overloaded"
+    })).toBe(true);
+  });
+  it("returns true for rate limit message", () => {
+    expect(isRetryableError({
+      message: "Rate limit exceeded"
+    })).toBe(true);
+  });
+  it("returns true for timeout message", () => {
+    expect(isRetryableError({
+      message: "Request timeout"
+    })).toBe(true);
+  });
+  it("returns false for generic error", () => {
+    expect(isRetryableError({
+      message: "something went wrong"
+    })).toBe(false);
+  });
+  it("handles statusCode property", () => {
+    expect(isRetryableError({
+      statusCode: 429
+    })).toBe(true);
+    expect(isRetryableError({
+      statusCode: 400
+    })).toBe(false);
+  });
+  it("handles null/undefined", () => {
+    expect(isRetryableError(null)).toBe(false);
+    expect(isRetryableError(undefined)).toBe(false);
+  });
+});

package/dist/shared/agent-core-tools.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Agent Core Tools — model config, cost tracking, caching, routing
+ * Extracted from agent-core.ts for modularity.
+ */
+import type { CompactableMessage } from "./compaction.js";
+import { type CompactionConfig, type ContextManagementConfig, type ContextManagementOverrides, type ThinkingConfig, type ErrorCategory } from "./agent-core-types.js";
+/** Legacy compaction trigger — used by getCompactionConfig() for non-Anthropic providers. */
+export declare const COMPACTION_TRIGGER_TOKENS = 167000;
+/** Max cumulative tokens before forcing wrap-up */
+export declare const COMPACTION_TOTAL_BUDGET = 2000000;
+/** Session cost safety cap — DB context_config.session_cost_budget_usd overrides */
+export declare const DEFAULT_SESSION_COST_BUDGET_USD = 25;
+export declare function getCompactionConfig(model: string): CompactionConfig;
+export declare function getContextManagement(model: string, overrides?: ContextManagementOverrides): ContextManagementConfig;
+export declare function addPromptCaching<T extends object = Record<string, unknown>, M extends CompactableMessage = CompactableMessage>(tools: T[], messages: M[]): {
+    tools: T[];
+    messages: M[];
+};
+export declare function getThinkingConfig(model: string, enabled: boolean): {
+    thinking: ThinkingConfig;
+    beta: string;
+};
+export declare function emitCostWarningIfNeeded(sessionCostUsd: number, maxCostUsd: number, costWarningsEmitted: Set<number>, onText?: (text: string) => void): void;
+export declare function estimateCostUsd(inputTokens: number, outputTokens: number, model: string, thinkingTokens?: number, cacheReadTokens?: number, cacheCreationTokens?: number): number;
+export declare function routeModel(message: string, requestedModel: string, forceModel?: boolean): string;
+export declare function categorizeError(err: unknown): {
+    category: ErrorCategory;
+    retryable: boolean;
+};
+export declare function isRetryableError(err: unknown): boolean;
+export declare function demoteSubagentModel(requested: string | undefined, agentType?: string): "haiku" | "sonnet" | "opus";
+export declare function sanitizeError(err: unknown): string;

package/dist/shared/agent-core-tools.js

@@ -0,0 +1,323 @@
+/**
+ * Agent Core Tools — model config, cost tracking, caching, routing
+ * Extracted from agent-core.ts for modularity.
+ */
+
+import { getProvider } from "./constants.js";
+import { AGENT_DEFAULTS, MODEL_PRICING } from "./agent-core-types.js";
+
+// ============================================================================
+// COMPACTION CONSTANTS — re-export from AGENT_DEFAULTS
+// ============================================================================
+
+/** Legacy compaction trigger — used by getCompactionConfig() for non-Anthropic providers. */
+export const COMPACTION_TRIGGER_TOKENS = 167_000;
+/** Max cumulative tokens before forcing wrap-up */
+export const COMPACTION_TOTAL_BUDGET = 2_000_000;
+/** Session cost safety cap — DB context_config.session_cost_budget_usd overrides */
+export const DEFAULT_SESSION_COST_BUDGET_USD = 25.00;
+
+// ============================================================================
+// MODEL-AWARE CONTEXT MANAGEMENT
+// ============================================================================
+
+export function getCompactionConfig(model) {
+  const provider = getProvider(model);
+  switch (provider) {
+    case "gemini":
+      return {
+        triggerTokens: 700_000,
+        totalBudget: 4_000_000,
+        isNative: false
+      };
+    case "openai":
+      return {
+        triggerTokens: 120_000,
+        totalBudget: 2_000_000,
+        isNative: false
+      };
+    case "bedrock":
+    case "anthropic":
+    default:
+      return {
+        triggerTokens: COMPACTION_TRIGGER_TOKENS,
+        totalBudget: COMPACTION_TOTAL_BUDGET,
+        isNative: true
+      };
+  }
+}
+export function getContextManagement(model, overrides) {
+  const provider = getProvider(model);
+  if (provider === "gemini" || provider === "openai") {
+    return {
+      betas: [],
+      config: {
+        edits: []
+      }
+    };
+  }
+  const edits = [];
+  const betas = ["context-management-2025-06-27"];
+  const clearThinkingKeep = overrides?.clear_thinking_keep ?? 1;
+  edits.push({
+    type: "clear_thinking_20251015",
+    keep: {
+      type: "thinking_turns",
+      value: clearThinkingKeep
+    }
+  });
+  const supportsCompaction = model.includes("opus-4-6") || model.includes("sonnet-4-6");
+  const compactionTrigger = overrides?.compaction_trigger_tokens ?? AGENT_DEFAULTS.compactionTriggerTokens;
+  if (supportsCompaction) {
+    edits.push({
+      type: "compact_20260112",
+      trigger: {
+        type: "input_tokens",
+        value: compactionTrigger
+      },
+      pause_after_compaction: true,
+      instructions: "Summarize the conversation preserving: (1) task goals and constraints, (2) files created/modified with paths, (3) decisions made and rationale, (4) errors encountered and resolutions, (5) exact next steps. Be concise but preserve all state needed to continue work without repeating mistakes."
+    });
+    betas.push("compact-2026-01-12");
+  }
+  const clearToolUsesTrigger = overrides?.clear_tool_uses_trigger ?? 100_000;
+  const clearToolUsesKeep = overrides?.clear_tool_uses_keep ?? 3;
+  edits.push({
+    type: "clear_tool_uses_20250919",
+    trigger: {
+      type: "input_tokens",
+      value: clearToolUsesTrigger
+    },
+    keep: {
+      type: "tool_uses",
+      value: clearToolUsesKeep
+    }
+  });
+  return {
+    betas,
+    config: {
+      edits
+    }
+  };
+}
+
+// ============================================================================
+// MULTI-BREAKPOINT PROMPT CACHING
+// ============================================================================
+
+export function addPromptCaching(tools, messages) {
+  const cachedTools = tools.length > 0 ? [...tools.slice(0, -1), {
+    ...tools[tools.length - 1],
+    cache_control: {
+      type: "ephemeral"
+    }
+  }] : [...tools];
+  const cachedMessages = [...messages];
+  if (cachedMessages.length >= 2) {
+    const idx = cachedMessages.length - 2;
+    const msg = cachedMessages[idx];
+    if (typeof msg.content === "string") {
+      cachedMessages[idx] = {
+        ...msg,
+        content: [{
+          type: "text",
+          text: msg.content,
+          cache_control: {
+            type: "ephemeral"
+          }
+        }]
+      };
+    } else if (Array.isArray(msg.content)) {
+      const blocks = [...msg.content];
+      blocks[blocks.length - 1] = {
+        ...blocks[blocks.length - 1],
+        cache_control: {
+          type: "ephemeral"
+        }
+      };
+      cachedMessages[idx] = {
+        ...msg,
+        content: blocks
+      };
+    }
+  }
+  return {
+    tools: cachedTools,
+    messages: cachedMessages
+  };
+}
+
+// ============================================================================
+// EXTENDED THINKING
+// ============================================================================
+
+export function getThinkingConfig(model, enabled) {
+  if (!enabled) {
+    return {
+      thinking: {
+        type: "disabled"
+      },
+      beta: ""
+    };
+  }
+  const provider = getProvider(model);
+  if (provider === "gemini") {
+    return {
+      thinking: {
+        type: "enabled"
+      },
+      beta: ""
+    };
+  }
+  if (provider === "openai") {
+    const isReasoning = /^o\d/.test(model);
+    return {
+      thinking: {
+        type: isReasoning ? "enabled" : "disabled"
+      },
+      beta: ""
+    };
+  }
+  if (model.includes("opus-4-6") || model.includes("sonnet-4-6")) {
+    return {
+      thinking: {
+        type: "adaptive"
+      },
+      beta: "adaptive-thinking-2026-01-28"
+    };
+  }
+  return {
+    thinking: {
+      type: "enabled",
+      budget_tokens: 31_999
+    },
+    beta: "interleaved-thinking-2025-05-14"
+  };
+}
+
+// ============================================================================
+// COST TRACKING
+// ============================================================================
+
+export function emitCostWarningIfNeeded(sessionCostUsd, maxCostUsd, costWarningsEmitted, onText) {
+  if (!isFinite(maxCostUsd) || !onText) return;
+  for (const pct of [25, 50, 75]) {
+    if (!costWarningsEmitted.has(pct) && sessionCostUsd >= maxCostUsd * (pct / 100)) {
+      costWarningsEmitted.add(pct);
+      onText(`\n[Cost warning: ${pct}% of budget used ($${sessionCostUsd.toFixed(2)}/$${maxCostUsd.toFixed(2)}).${pct >= 75 ? " Wrap up soon." : ""}]`);
+    }
+  }
+}
+export function estimateCostUsd(inputTokens, outputTokens, model, thinkingTokens = 0, cacheReadTokens = 0, cacheCreationTokens = 0) {
+  const pricing = MODEL_PRICING[model] || MODEL_PRICING[Object.keys(MODEL_PRICING).find(k => model.startsWith(k)) ?? ""] || MODEL_PRICING["claude-sonnet-4-6"];
+  const thinkingRate = pricing.thinkingPer1M || pricing.outputPer1M;
+  const inputRate = pricing.inputPer1M;
+
+  // Base cost
+  let cost = inputTokens / 1_000_000 * inputRate + outputTokens / 1_000_000 * pricing.outputPer1M + thinkingTokens / 1_000_000 * thinkingRate;
+
+  // Cache pricing — subtract savings for cached tokens
+  if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
+    const provider = getProvider(model);
+    if (provider === "anthropic" || provider === "bedrock") {
+      cost -= cacheReadTokens / 1_000_000 * inputRate * 0.9;
+      cost += cacheCreationTokens / 1_000_000 * inputRate * 0.25;
+    } else if (provider === "openai") {
+      cost -= cacheReadTokens / 1_000_000 * inputRate * 0.5;
+    } else if (provider === "gemini") {
+      cost -= cacheReadTokens / 1_000_000 * inputRate * 0.75;
+    }
+  }
+  return cost;
+}
+
+// ============================================================================
+// MODEL ROUTING BY TASK COMPLEXITY
+// ============================================================================
+
+export function routeModel(message, requestedModel, forceModel) {
+  if (forceModel) return requestedModel;
+  const estimatedTokens = Math.ceil(message.length / 4);
+  const simplePatterns = /^(what|who|when|where|show|list|get|find|look ?up|check)\b/i;
+  const complexPatterns = /\b(analyze|implement|refactor|design|architect|debug|explain why|compare|evaluate|write|create|build|fix)\b/i;
+  if (estimatedTokens < 50 && simplePatterns.test(message) && !complexPatterns.test(message)) {
+    return "claude-haiku-4-5-20251001";
+  }
+  if (estimatedTokens < 200 && !complexPatterns.test(message)) {
+    return "claude-sonnet-4-5-20250929";
+  }
+  return requestedModel;
+}
+
+// ============================================================================
+// ERROR CATEGORIZATION
+// ============================================================================
+
+export function categorizeError(err) {
+  const e = err;
+  const status = e?.status || e?.statusCode;
+  const msg = String(e?.message || "").toLowerCase();
+  if (status === 429 || msg.includes("rate limit")) {
+    return {
+      category: "RATE_LIMIT",
+      retryable: true
+    };
+  }
+  if (status === 401 || status === 403 || msg.includes("unauthorized") || msg.includes("forbidden") || msg.includes("invalid api key")) {
+    return {
+      category: "AUTH",
+      retryable: false
+    };
+  }
+  if (status === 400 || msg.includes("malformed") || msg.includes("invalid") || msg.includes("validation")) {
+    return {
+      category: "MALFORMED",
+      retryable: false
+    };
+  }
+  if (status === 500 || status === 502 || status === 503 || status === 529 || msg.includes("overloaded") || msg.includes("internal server error")) {
+    return {
+      category: "PROVIDER_DOWN",
+      retryable: true
+    };
+  }
+  if (msg.includes("timeout") || msg.includes("timed out") || msg.includes("deadline") || msg.includes("econnreset") || msg.includes("stream stalled")) {
+    return {
+      category: "TIMEOUT",
+      retryable: true
+    };
+  }
+  if (msg.includes("econnrefused") || msg.includes("enetunreach") || msg.includes("enotfound") || msg.includes("fetch failed") || msg.includes("network")) {
+    return {
+      category: "NETWORK",
+      retryable: true
+    };
+  }
+  return {
+    category: "UNKNOWN",
+    retryable: false
+  };
+}
+export function isRetryableError(err) {
+  return categorizeError(err).retryable;
+}
+
+// ============================================================================
+// UTILITY — model demotion, sanitize errors
+// ============================================================================
+
+export function demoteSubagentModel(requested, agentType) {
+  if (agentType === "explore" || agentType === "research") return "haiku";
+  if (agentType === "general-purpose" || agentType === "plan") {
+    if (requested === "opus") return "opus";
+    if (requested === "sonnet") return "sonnet";
+    return "sonnet";
+  }
+  if (!requested) return "haiku";
+  return requested === "opus" ? "sonnet" : requested === "sonnet" ? "sonnet" : "haiku";
+}
+export function sanitizeError(err) {
+  const msg = String(err);
+  return msg.replace(/sk-[a-zA-Z0-9_-]+/g, "sk-***").replace(/AIzaSy[a-zA-Z0-9_-]+/g, "AIzaSy***").replace(/AKIA[A-Z0-9]{16}/g, "AKIA***").replace(/key[=:]\s*["']?[a-zA-Z0-9_-]{20,}["']?/gi, "key=***").replace(/password[=:]\s*["']?[^\s"']+["']?/gi, "password=***").replace(/\n\s+at\s+.*/g, "").substring(0, 500);
+}
+//# sourceMappingURL=agent-core-tools.js.map