ashlrcode 1.0.0

package/src/providers/anthropic.ts

@@ -0,0 +1,177 @@
+/**
+ * Anthropic Claude provider — uses the official Anthropic SDK.
+ * Fallback provider for when Claude API access is available.
+ */
+
+import Anthropic from "@anthropic-ai/sdk";
+import type {
+  Provider,
+  ProviderConfig,
+  ProviderRequest,
+  StreamEvent,
+} from "./types.ts";
+import { withRetry } from "./retry.ts";
+
+export function createAnthropicProvider(config: ProviderConfig): Provider {
+  const client = new Anthropic({
+    apiKey: config.apiKey,
+    ...(config.baseURL ? { baseURL: config.baseURL } : {}),
+  });
+
+  return {
+    name: "anthropic",
+    config,
+    pricing: [3.0, 15.0], // Sonnet 4.6 per million tokens
+
+    async *stream(request: ProviderRequest): AsyncGenerator<StreamEvent> {
+      const tools: Anthropic.Tool[] = request.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.input_schema as Anthropic.Tool.InputSchema,
+      }));
+
+      const messages: Anthropic.MessageParam[] = request.messages.map(
+        convertMessage
+      );
+
+      // Use withRetry to create the stream, then iterate it.
+      // Anthropic SDK errors can surface during both creation and iteration,
+      // so we wrap the entire stream lifecycle in a retry-able unit.
+      const createAndConsumeStream = async (): Promise<StreamEvent[]> => {
+        const events: StreamEvent[] = [];
+        const stream = client.messages.stream({
+          model: config.model,
+          system: request.systemPrompt,
+          messages,
+          tools: tools.length > 0 ? tools : undefined,
+          max_tokens: request.maxTokens ?? config.maxTokens ?? 8192,
+        });
+
+        for await (const event of stream) {
+          switch (event.type) {
+            case "content_block_delta": {
+              const delta = event.delta;
+              if (delta.type === "text_delta") {
+                events.push({ type: "text_delta", text: delta.text });
+              } else if (delta.type === "input_json_delta") {
+                events.push({
+                  type: "tool_call_delta",
+                  text: delta.partial_json,
+                });
+              }
+              break;
+            }
+
+            case "content_block_start": {
+              const block = event.content_block;
+              if (block.type === "tool_use") {
+                events.push({
+                  type: "tool_call_start",
+                  toolCall: { id: block.id, name: block.name },
+                });
+              }
+              break;
+            }
+
+            case "content_block_stop":
+              break;
+
+            case "message_delta": {
+              const delta = event.delta;
+              events.push({
+                type: "message_end",
+                stopReason:
+                  delta.stop_reason === "tool_use"
+                    ? "tool_use"
+                    : delta.stop_reason === "max_tokens"
+                      ? "max_tokens"
+                      : "end_turn",
+                usage: {
+                  inputTokens: 0,
+                  outputTokens: event.usage?.output_tokens ?? 0,
+                },
+              });
+              break;
+            }
+
+            case "message_start": {
+              if (event.message.usage) {
+                events.push({
+                  type: "usage",
+                  usage: {
+                    inputTokens: event.message.usage.input_tokens,
+                    outputTokens: event.message.usage.output_tokens,
+                  },
+                });
+              }
+              break;
+            }
+          }
+        }
+
+        // Extract completed tool calls from the final message
+        const finalMessage = await stream.finalMessage();
+        for (const block of finalMessage.content) {
+          if (block.type === "tool_use") {
+            events.push({
+              type: "tool_call_end",
+              toolCall: {
+                id: block.id,
+                name: block.name,
+                input: block.input as Record<string, unknown>,
+              },
+            });
+          }
+        }
+
+        return events;
+      };
+
+      const events = await withRetry(createAndConsumeStream, {
+        providerName: "anthropic",
+      });
+
+      for (const event of events) {
+        yield event;
+      }
+    },
+  };
+}
+
+function convertMessage(
+  msg: ProviderRequest["messages"][number]
+): Anthropic.MessageParam {
+  if (typeof msg.content === "string") {
+    return { role: msg.role === "tool" ? "user" : msg.role, content: msg.content };
+  }
+
+  const blocks: Anthropic.ContentBlockParam[] = msg.content
+    .filter((b) => b.type !== "image_url") // Anthropic uses different image format
+    .map((b) => {
+    switch (b.type) {
+      case "text":
+        return { type: "text" as const, text: b.text };
+      case "tool_use":
+        return {
+          type: "tool_use" as const,
+          id: b.id,
+          name: b.name,
+          input: b.input,
+        };
+      case "tool_result":
+        return {
+          type: "tool_result" as const,
+          tool_use_id: b.tool_use_id,
+          content: b.content,
+          is_error: b.is_error,
+        };
+      default:
+        return { type: "text" as const, text: "" };
+    }
+  }).filter(b => b.type !== "text" || b.text !== "");
+
+  return {
+    role: msg.role === "tool" ? "user" : msg.role,
+    content: blocks,
+  };
+}

package/src/providers/cost-tracker.ts

@@ -0,0 +1,184 @@
+/**
+ * Detailed cost tracking — per-provider, per-model pricing with reasoning tokens.
+ */
+
+interface ModelPricing {
+  inputPerMillion: number;
+  outputPerMillion: number;
+  reasoningPerMillion?: number; // Some models charge extra for reasoning tokens
+}
+
+// Pricing tables (USD per million tokens)
+const PRICING: Record<string, ModelPricing> = {
+  // xAI
+  "grok-4-1-fast-reasoning": {
+    inputPerMillion: 0.2,
+    outputPerMillion: 0.5,
+  },
+  "grok-4-0314": { inputPerMillion: 2.0, outputPerMillion: 4.0 },
+  "grok-3-fast": { inputPerMillion: 0.1, outputPerMillion: 0.3 },
+  // Anthropic
+  "claude-opus-4-6-20250514": {
+    inputPerMillion: 15.0,
+    outputPerMillion: 75.0,
+  },
+  "claude-sonnet-4-6-20250514": {
+    inputPerMillion: 3.0,
+    outputPerMillion: 15.0,
+  },
+  "claude-haiku-4-5-20251001": {
+    inputPerMillion: 0.8,
+    outputPerMillion: 4.0,
+  },
+  // OpenAI
+  "gpt-4o": { inputPerMillion: 2.5, outputPerMillion: 10.0 },
+  "gpt-4o-mini": { inputPerMillion: 0.15, outputPerMillion: 0.6 },
+  o1: {
+    inputPerMillion: 15.0,
+    outputPerMillion: 60.0,
+    reasoningPerMillion: 60.0,
+  },
+  "o1-mini": {
+    inputPerMillion: 3.0,
+    outputPerMillion: 12.0,
+    reasoningPerMillion: 12.0,
+  },
+  // DeepSeek
+  "deepseek-chat": { inputPerMillion: 0.14, outputPerMillion: 0.28 },
+  "deepseek-reasoner": {
+    inputPerMillion: 0.55,
+    outputPerMillion: 2.19,
+    reasoningPerMillion: 2.19,
+  },
+  // Groq (free tier, nominal costs)
+  "llama-3.3-70b-versatile": { inputPerMillion: 0.0, outputPerMillion: 0.0 },
+  // Local (Ollama)
+  "llama3.2": { inputPerMillion: 0.0, outputPerMillion: 0.0 },
+};
+
+function getPricing(model: string): ModelPricing {
+  // Exact match first
+  if (PRICING[model]) return PRICING[model];
+  // Partial match (model might have date suffix)
+  for (const [key, pricing] of Object.entries(PRICING)) {
+    if (model.startsWith(key) || key.startsWith(model)) return pricing;
+  }
+  // Unknown model — assume moderate pricing
+  return { inputPerMillion: 1.0, outputPerMillion: 3.0 };
+}
+
+export interface TokenUsageTotals {
+  inputTokens: number;
+  outputTokens: number;
+  reasoningTokens: number;
+}
+
+export interface ProviderCostEntry {
+  provider: string;
+  model: string;
+  usage: TokenUsageTotals;
+  costUSD: number;
+  calls: number;
+}
+
+export class CostTracker {
+  private entries = new Map<string, ProviderCostEntry>();
+
+  /** Record token usage for a single API call */
+  record(
+    provider: string,
+    model: string,
+    usage: Partial<TokenUsageTotals>
+  ): void {
+    const key = `${provider}:${model}`;
+    const existing = this.entries.get(key) ?? {
+      provider,
+      model,
+      usage: { inputTokens: 0, outputTokens: 0, reasoningTokens: 0 },
+      costUSD: 0,
+      calls: 0,
+    };
+
+    existing.usage.inputTokens += usage.inputTokens ?? 0;
+    existing.usage.outputTokens += usage.outputTokens ?? 0;
+    existing.usage.reasoningTokens += usage.reasoningTokens ?? 0;
+    existing.calls++;
+
+    // Recalculate cost from totals to avoid floating-point drift
+    const pricing = getPricing(model);
+    existing.costUSD =
+      (existing.usage.inputTokens / 1_000_000) * pricing.inputPerMillion +
+      (existing.usage.outputTokens / 1_000_000) * pricing.outputPerMillion +
+      (existing.usage.reasoningTokens / 1_000_000) *
+        (pricing.reasoningPerMillion ?? pricing.outputPerMillion);
+
+    this.entries.set(key, existing);
+  }
+
+  /** Get total cost across all providers */
+  get totalCostUSD(): number {
+    let total = 0;
+    for (const entry of this.entries.values()) total += entry.costUSD;
+    return total;
+  }
+
+  /** Get total tokens */
+  get totalTokens(): TokenUsageTotals {
+    const total: TokenUsageTotals = {
+      inputTokens: 0,
+      outputTokens: 0,
+      reasoningTokens: 0,
+    };
+    for (const entry of this.entries.values()) {
+      total.inputTokens += entry.usage.inputTokens;
+      total.outputTokens += entry.usage.outputTokens;
+      total.reasoningTokens += entry.usage.reasoningTokens;
+    }
+    return total;
+  }
+
+  /** Get per-provider breakdown */
+  getBreakdown(): ProviderCostEntry[] {
+    return Array.from(this.entries.values());
+  }
+
+  /** Format a detailed cost summary */
+  formatSummary(): string {
+    const total = this.totalTokens;
+    const entries = this.getBreakdown();
+
+    const lines: string[] = [`Cost: $${this.totalCostUSD.toFixed(4)}`];
+    lines.push(
+      `Tokens: ${formatTokens(total.inputTokens)} in / ${formatTokens(total.outputTokens)} out${total.reasoningTokens > 0 ? ` / ${formatTokens(total.reasoningTokens)} reasoning` : ""}`
+    );
+
+    if (entries.length > 1) {
+      lines.push("Per provider:");
+      for (const e of entries) {
+        lines.push(
+          `  ${e.provider}:${e.model} — $${e.costUSD.toFixed(4)} (${e.calls} calls)`
+        );
+      }
+    }
+
+    return lines.join("\n");
+  }
+
+  // ── Legacy compat: expose the same shape the old CostTracker interface had ──
+
+  get totalInputTokens(): number {
+    return this.totalTokens.inputTokens;
+  }
+  get totalOutputTokens(): number {
+    return this.totalTokens.outputTokens;
+  }
+  get totalReasoningTokens(): number {
+    return this.totalTokens.reasoningTokens;
+  }
+}
+
+function formatTokens(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(0)}K`;
+  return `${n}`;
+}

package/src/providers/retry.ts

@@ -0,0 +1,264 @@
+/**
+ * Retry logic — exponential backoff with jitter for API calls.
+ * Circuit breaker pattern to stop hammering a failing provider.
+ *
+ * Centralizes retry behavior previously duplicated across xai.ts and anthropic.ts.
+ */
+
+import { categorizeError, type CategorizedError } from "../agent/error-handler.ts";
+
+// ── Retry Config ──────────────────────────────────────────────────────
+
+export interface RetryConfig {
+  /** Max retry attempts per error category */
+  maxRetriesRateLimit: number;
+  maxRetriesNetwork: number;
+  maxRetriesServer: number;
+  /** Base delay in ms before first retry (doubles each attempt) */
+  baseDelayMs: number;
+  /** Absolute max delay cap */
+  maxDelayMs: number;
+  /** Provider name for log messages */
+  providerName: string;
+}
+
+const DEFAULT_CONFIG: RetryConfig = {
+  maxRetriesRateLimit: 3,
+  maxRetriesNetwork: 2,
+  maxRetriesServer: 2,
+  baseDelayMs: 1000,
+  maxDelayMs: 30_000,
+  providerName: "provider",
+};
+
+// ── Retry Error ───────────────────────────────────────────────────────
+
+export class RetryError extends Error {
+  constructor(
+    message: string,
+    public readonly attempts: number,
+    public readonly lastCategory?: string,
+    public readonly lastStatus?: number,
+  ) {
+    super(message);
+    this.name = "RetryError";
+  }
+}
+
+// ── Core retry function ───────────────────────────────────────────────
+
+/**
+ * Execute a function with category-aware exponential backoff and jitter.
+ *
+ * - Rate limit (429): up to maxRetriesRateLimit retries
+ * - Network errors: up to maxRetriesNetwork retries
+ * - Server errors (500/502/503/504/529): up to maxRetriesServer retries
+ * - Auth errors (401/403): fail immediately
+ * - Unknown non-retryable errors: fail immediately
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  config: Partial<RetryConfig> = {},
+): Promise<T> {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  let lastError: Error | null = null;
+  let lastCategorized: CategorizedError | null = null;
+
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      lastCategorized = categorizeError(lastError);
+
+      // Auth errors: fail immediately with clear message
+      if (lastCategorized.category === "auth") {
+        throw new Error(
+          `[${cfg.providerName}] Authentication failed — check your API key. (${lastError.message})`,
+        );
+      }
+
+      // Determine max retries for this error category
+      const maxRetries = getMaxRetries(lastCategorized, cfg);
+
+      if (!lastCategorized.retryable || attempt >= maxRetries) {
+        throw lastError;
+      }
+
+      // Calculate delay with exponential backoff + jitter
+      const delay = calculateDelay(attempt, lastCategorized, cfg);
+
+      process.stderr.write(
+        `[${cfg.providerName}] ${lastCategorized.category} error, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})...\n`,
+      );
+
+      await sleep(delay);
+    }
+  }
+}
+
+/**
+ * Wrap an async generator with retry — recreates the generator on failure.
+ * Used for streaming API calls where errors can surface mid-iteration.
+ */
+export async function* withStreamRetry<T>(
+  createStream: () => AsyncGenerator<T>,
+  config: Partial<RetryConfig> = {},
+): AsyncGenerator<T> {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  let lastError: Error | null = null;
+
+  for (let attempt = 0; ; attempt++) {
+    const stream = createStream();
+    try {
+      for await (const event of stream) {
+        yield event;
+      }
+      return; // Stream completed successfully
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      const categorized = categorizeError(lastError);
+
+      // Auth: fail fast
+      if (categorized.category === "auth") {
+        throw new Error(
+          `[${cfg.providerName}] Authentication failed — check your API key. (${lastError.message})`,
+        );
+      }
+
+      const maxRetries = getMaxRetries(categorized, cfg);
+
+      if (!categorized.retryable || attempt >= maxRetries) {
+        throw lastError;
+      }
+
+      const delay = calculateDelay(attempt, categorized, cfg);
+      process.stderr.write(
+        `[${cfg.providerName}] ${categorized.category} error mid-stream, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})...\n`,
+      );
+
+      await sleep(delay);
+      // Loop re-creates the stream from scratch
+    }
+  }
+}
+
+// ── Circuit Breaker ───────────────────────────────────────────────────
+
+export type CircuitState = "closed" | "open" | "half-open";
+
+/**
+ * Circuit breaker — stop hammering a provider after consecutive failures.
+ *
+ * States:
+ * - closed: requests flow normally
+ * - open: requests are blocked (too many failures)
+ * - half-open: one probe request allowed to test recovery
+ */
+export class CircuitBreaker {
+  private failures = 0;
+  private lastFailureTime = 0;
+  private state: CircuitState = "closed";
+  private probeInFlight = false;
+
+  constructor(
+    /** Number of consecutive failures before opening the circuit */
+    private readonly threshold: number = 5,
+    /** Time in ms before an open circuit transitions to half-open */
+    private readonly resetTimeMs: number = 60_000,
+  ) {}
+
+  /** Check if a request should be allowed through */
+  canRequest(): boolean {
+    if (this.state === "closed") return true;
+
+    if (this.state === "open") {
+      // Check if enough time has passed to try again
+      if (Date.now() - this.lastFailureTime >= this.resetTimeMs) {
+        this.state = "half-open";
+        this.probeInFlight = true;
+        return true;
+      }
+      return false;
+    }
+
+    // half-open: allow only one probe request at a time
+    if (this.probeInFlight) return false;
+    this.probeInFlight = true;
+    return true;
+  }
+
+  /** Record a successful request — resets failure count */
+  recordSuccess(): void {
+    this.failures = 0;
+    this.state = "closed";
+    this.probeInFlight = false;
+  }
+
+  /** Record a failed request — may trip the breaker */
+  recordFailure(): void {
+    this.probeInFlight = false;
+    this.failures++;
+    this.lastFailureTime = Date.now();
+    if (this.failures >= this.threshold) {
+      this.state = "open";
+    }
+  }
+
+  getState(): CircuitState {
+    // Re-check for time-based transition
+    if (this.state === "open" && Date.now() - this.lastFailureTime >= this.resetTimeMs) {
+      this.state = "half-open";
+    }
+    return this.state;
+  }
+
+  getStatus(): string {
+    return `${this.getState()} (${this.failures}/${this.threshold} failures)`;
+  }
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────
+
+function getMaxRetries(categorized: CategorizedError, cfg: RetryConfig): number {
+  switch (categorized.category) {
+    case "rate_limit":
+      return cfg.maxRetriesRateLimit;
+    case "network":
+      return cfg.maxRetriesNetwork;
+    default:
+      // Server errors (5xx) are retryable if categorized as such
+      return categorized.retryable ? cfg.maxRetriesServer : 0;
+  }
+}
+
+function calculateDelay(
+  attempt: number,
+  categorized: CategorizedError,
+  cfg: RetryConfig,
+): number {
+  // If the error includes a Retry-After hint, use it
+  if (categorized.retryAfterMs && categorized.retryAfterMs > 0) {
+    return Math.min(categorized.retryAfterMs, cfg.maxDelayMs);
+  }
+
+  // Rate limits get a higher base delay
+  const baseDelay =
+    categorized.category === "rate_limit"
+      ? cfg.baseDelayMs
+      : categorized.category === "network"
+        ? cfg.baseDelayMs * 2
+        : cfg.baseDelayMs;
+
+  // Exponential backoff: base * 2^attempt
+  const exponential = baseDelay * Math.pow(2, attempt);
+
+  // Add jitter: ±25% randomization to prevent thundering herd
+  const jitter = exponential * 0.25 * (Math.random() * 2 - 1);
+
+  return Math.min(Math.round(exponential + jitter), cfg.maxDelayMs);
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}