@planningo/duul 1.0.0

package/build/services/pricing.js

@@ -0,0 +1,105 @@
+/**
+ * Model pricing table and cost estimation.
+ *
+ * Prices are per 1M tokens in USD.
+ * Update this table when new models or pricing changes occur.
+ * Set env DUUL_PRICING_JSON to a JSON file path to override/extend.
+ */
+import { readFileSync } from 'node:fs';
+// Key: model name or prefix. Longest prefix match wins.
+const PRICING_TABLE = {
+    // OpenAI — GPT
+    'gpt-4o-mini': { input: 0.15, output: 0.60 },
+    'gpt-4o': { input: 2.50, output: 10.00 },
+    'gpt-4.1-nano': { input: 0.10, output: 0.40 },
+    'gpt-4.1-mini': { input: 0.40, output: 1.60 },
+    'gpt-4.1': { input: 2.00, output: 8.00 },
+    'gpt-4.5-preview': { input: 75.00, output: 150.00 },
+    'gpt-5': { input: 2.00, output: 8.00 },
+    'gpt-5.4': { input: 2.00, output: 8.00 },
+    // OpenAI — o-series (reasoning)
+    'o4-mini': { input: 1.10, output: 4.40 },
+    'o3': { input: 2.00, output: 8.00 },
+    'o3-pro': { input: 20.00, output: 80.00 },
+    'o3-mini': { input: 1.10, output: 4.40 },
+    'o1': { input: 15.00, output: 60.00 },
+    'o1-mini': { input: 1.10, output: 4.40 },
+    'o1-preview': { input: 15.00, output: 60.00 },
+    // Anthropic — Claude
+    'claude-opus-4': { input: 15.00, output: 75.00 },
+    'claude-sonnet-4': { input: 3.00, output: 15.00 },
+    'claude-haiku-4': { input: 0.80, output: 4.00 },
+    'claude-3.5-sonnet': { input: 3.00, output: 15.00 },
+    'claude-3.5-haiku': { input: 0.80, output: 4.00 },
+    'claude-3-opus': { input: 15.00, output: 75.00 },
+    'claude-3-sonnet': { input: 3.00, output: 15.00 },
+    'claude-3-haiku': { input: 0.25, output: 1.25 },
+    // Google — Gemini
+    'gemini-2.5-pro': { input: 1.25, output: 10.00 },
+    'gemini-2.5-flash': { input: 0.15, output: 0.60 },
+    'gemini-2.0-flash': { input: 0.10, output: 0.40 },
+    'gemini-3': { input: 1.25, output: 10.00 },
+    'gemini-3.1-pro': { input: 1.25, output: 10.00 },
+};
+// Custom pricing loaded lazily from DUUL_PRICING_JSON
+let customPricing = null;
+function loadCustomPricing() {
+    if (customPricing !== null)
+        return customPricing;
+    customPricing = {};
+    const envPath = process.env.DUUL_PRICING_JSON;
+    if (envPath) {
+        try {
+            const data = JSON.parse(readFileSync(envPath, 'utf-8'));
+            if (typeof data === 'object' && data !== null) {
+                customPricing = data;
+                console.error(`[duul] Loaded custom pricing from ${envPath} (${Object.keys(customPricing).length} models)`);
+            }
+        }
+        catch {
+            console.error(`[duul] Failed to load custom pricing from ${envPath}, using defaults`);
+        }
+    }
+    return customPricing;
+}
+function findPricing(model) {
+    const custom = loadCustomPricing();
+    // Exact match (custom first, then built-in)
+    if (custom[model])
+        return custom[model];
+    if (PRICING_TABLE[model])
+        return PRICING_TABLE[model];
+    // Longest prefix match (e.g. "gpt-4.1-mini-2025-04-14" → "gpt-4.1-mini")
+    let bestMatch = null;
+    let bestLen = 0;
+    const allKeys = [...Object.keys(custom), ...Object.keys(PRICING_TABLE)];
+    for (const key of allKeys) {
+        if (model.startsWith(key) && key.length > bestLen) {
+            bestMatch = custom[key] ?? PRICING_TABLE[key];
+            bestLen = key.length;
+        }
+    }
+    return bestMatch;
+}
+/**
+ * Cache-aware cost estimate. `inputTokens` is the provider-reported total input
+ * bucket. `cachedInputTokens` (cache reads, 0.1× input price) and
+ * `cacheCreationTokens` (Anthropic cache writes, 1.25× input price) are
+ * already included in that total, so we subtract them from the full-price
+ * bucket before pricing.
+ */
+export function estimateCost(model, inputTokens, outputTokens, cachedInputTokens = 0, cacheCreationTokens = 0) {
+    const pricing = findPricing(model);
+    if (!pricing)
+        return null;
+    const cached = Math.max(0, cachedInputTokens);
+    const cacheWrite = Math.max(0, cacheCreationTokens);
+    const nonCachedInput = Math.max(0, inputTokens - cached - cacheWrite);
+    const nonCachedInputCost = (nonCachedInput / 1_000_000) * pricing.input;
+    const cacheReadCost = (cached / 1_000_000) * pricing.input * 0.1;
+    const cacheWriteCost = (cacheWrite / 1_000_000) * pricing.input * 1.25;
+    const outputCost = (outputTokens / 1_000_000) * pricing.output;
+    const total = nonCachedInputCost + cacheReadCost + cacheWriteCost + outputCost;
+    // Round to 6 decimal places to avoid floating point noise
+    return Math.round(total * 1_000_000) / 1_000_000;
+}

package/build/services/providers/anthropic.d.ts

@@ -0,0 +1,28 @@
+import type { z } from 'zod';
+import type { ReviewerProvider, ReviewCallOptions, ReviewCallResult, ProviderCapabilities } from './types.js';
+/**
+ * Anthropic provider — uses Claude models via the Anthropic Messages API.
+ *
+ * Capabilities:
+ * - Tool calling via native Anthropic tools parameter
+ * - Conversation history for simulated context persistence across rounds
+ * - No native structured outputs (uses JSON prompt + zod validation)
+ */
+export declare class AnthropicProvider implements ReviewerProvider {
+    readonly name = "anthropic";
+    readonly capabilities: ProviderCapabilities;
+    private apiKey;
+    private baseUrl;
+    private model;
+    private temperature;
+    private topP;
+    constructor(config?: {
+        apiKey?: string;
+        baseUrl?: string;
+        model?: string;
+        temperature?: number;
+        topP?: number;
+    });
+    review<T extends z.ZodType>(options: ReviewCallOptions<T>): Promise<ReviewCallResult<z.infer<T>>>;
+    private apiCallWithRetry;
+}

package/build/services/providers/anthropic.js

@@ -0,0 +1,431 @@
+import { validateProjectRoot } from '../filesystem.js';
+import { executeFilesystemTool } from '../filesystem-tools.js';
+import { estimateCost } from '../pricing.js';
+const MAX_INPUT_CHARS = 400_000;
+const MAX_TOOL_ROUNDS = 10;
+const MAX_RETRIES = 3;
+const MAX_REPEAT_CALLS = 3;
+const LINKED_PATH_HINT = ' To access a linked root, prefix with "linked:<index>:<path>" (e.g. "linked:0:src/types.ts").';
+/**
+ * Anthropic tool definitions in Claude Messages API format.
+ * `cache_control` on the last tool marks the end of the static tool prefix
+ * so Anthropic caches system + all tools as one contiguous block.
+ */
+const ANTHROPIC_TOOLS = [
+    {
+        name: 'read_file',
+        description: 'Read a file from the project being reviewed. Use this to examine type definitions, ' +
+            'data models, interfaces, utility functions, and any code you need for thorough review context. ' +
+            'Returns file contents as text.' + LINKED_PATH_HINT,
+        input_schema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Relative path from project root, or "linked:<index>:<path>" for linked roots' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'list_directory',
+        description: 'List files and directories at a path in the project. Use this to understand project structure.' + LINKED_PATH_HINT,
+        input_schema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Relative path from project root. Use "." for project root, or "linked:<index>:<path>" for linked roots.' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'search_in_files',
+        description: 'Search for a pattern across project files. Uses ripgrep when available, falls back to git grep. ' +
+            'PREFER this over read_file when you need to find specific symbols, keywords, or patterns. ' +
+            'Returns matching lines with file paths and line numbers.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search pattern (literal string or regex)' },
+                paths: { type: 'array', items: { type: 'string' }, description: 'Optional: restrict search to these relative paths/directories' },
+                glob: { type: 'string', description: 'Optional: glob pattern to filter files (e.g. "*.ts", "src/**/*.js")' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'read_file_range',
+        description: 'Read a specific line range from a file. PREFER this over read_file for large files. Returns numbered lines. Max 200 lines per call.' + LINKED_PATH_HINT,
+        input_schema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Relative path from project root, or "linked:<index>:<path>" for linked roots' },
+                start_line: { type: 'number', description: 'First line to read (1-based)' },
+                end_line: { type: 'number', description: 'Last line to read (1-based, inclusive)' },
+            },
+            required: ['path', 'start_line', 'end_line'],
+        },
+    },
+    {
+        name: 'stat_file',
+        description: 'Get file metadata: size, type, and modification time. Use this before read_file to check if a file is too large.' + LINKED_PATH_HINT,
+        input_schema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Relative path from project root, or "linked:<index>:<path>" for linked roots' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'read_json',
+        description: 'Read a JSON file, optionally extracting a value at a JSON pointer path. Use this for package.json, tsconfig.json, etc.' + LINKED_PATH_HINT,
+        input_schema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Relative path to a JSON file, or "linked:<index>:<path>" for linked roots' },
+                json_pointer: { type: 'string', description: 'Optional: JSON pointer (e.g. "/dependencies", "/scripts/build")' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'list_tracked_files',
+        description: 'List git-tracked files, optionally filtered by a directory prefix. Only shows files committed to git.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                prefix: { type: 'string', description: 'Optional: directory prefix to filter (e.g. "src/")' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'get_git_diff',
+        description: 'Get git diff output for the workspace. Use this to see exactly what changed — ' +
+            'PREFER this over reading full files when reviewing modifications. ' +
+            'Returns unified diff format. Defaults to comparing against HEAD (current workspace changes). Also includes untracked new files.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                base: { type: 'string', description: 'Base ref to diff against (e.g. "HEAD~1", "main", a commit SHA). Defaults to HEAD.' },
+                paths: { type: 'array', items: { type: 'string' }, description: 'Optional: restrict diff to these relative paths' },
+            },
+            required: [],
+        },
+        cache_control: { type: 'ephemeral' },
+    },
+];
+const FULL_READ_TOOLS = new Set(['read_file', 'get_git_diff']);
+const SEARCH_ONLY_TOOLS = new Set(['search_in_files', 'list_tracked_files', 'stat_file']);
+/**
+ * Anthropic provider — uses Claude models via the Anthropic Messages API.
+ *
+ * Capabilities:
+ * - Tool calling via native Anthropic tools parameter
+ * - Conversation history for simulated context persistence across rounds
+ * - No native structured outputs (uses JSON prompt + zod validation)
+ */
+export class AnthropicProvider {
+    name = 'anthropic';
+    capabilities = {
+        structuredOutputs: false,
+        toolCalling: true,
+        previousResponseId: true, // simulated via conversation history
+        jsonSchemaStrict: false,
+    };
+    apiKey;
+    baseUrl;
+    model;
+    temperature;
+    topP;
+    constructor(config) {
+        const apiKey = config?.apiKey ?? process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            throw new Error('ANTHROPIC_API_KEY environment variable is not set');
+        }
+        this.apiKey = apiKey;
+        this.baseUrl = config?.baseUrl ?? 'https://api.anthropic.com';
+        this.model = config?.model ?? 'claude-opus-4-20250514';
+        this.temperature = config?.temperature ?? 0.2;
+        this.topP = config?.topP ?? 0.1;
+    }
+    async review(options) {
+        const { systemPrompt, userMessage, outputSchema, workspaceScope, conversationHistory } = options;
+        const effectiveRoot = workspaceScope?.root ?? null;
+        if (effectiveRoot && !workspaceScope) {
+            validateProjectRoot(effectiveRoot);
+        }
+        // Append JSON schema instruction to system prompt
+        const schemaJson = JSON.stringify(zodToJsonSchema(outputSchema), null, 2);
+        const enhancedSystem = `${systemPrompt}\n\n## Output Format\nYou MUST respond with ONLY a valid JSON object matching this schema. No markdown, no explanation, no code blocks — only the JSON object.\n\n${schemaJson}`;
+        // Wrap system prompt in a cacheable block so the provider returns
+        // cache_read_input_tokens on rounds 2+.
+        const systemBlocks = [
+            { type: 'text', text: enhancedSystem, cache_control: { type: 'ephemeral' } },
+        ];
+        const tools = effectiveRoot ? ANTHROPIC_TOOLS : undefined;
+        let allUsedTools = [];
+        // Accumulate token usage across all API calls
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        let totalCachedInputTokens = 0;
+        let totalCacheCreationTokens = 0;
+        let apiCallCount = 0;
+        const accumulateUsage = (body) => {
+            apiCallCount++;
+            if (body.usage) {
+                // Anthropic reports input_tokens, cache_read_input_tokens, and
+                // cache_creation_input_tokens as three disjoint buckets. Sum them so
+                // totalInputTokens matches OpenAI's convention (cached tokens included
+                // in the input total) — that keeps total_tokens and estimateCost correct.
+                const nonCachedInput = body.usage.input_tokens ?? 0;
+                const cacheRead = body.usage.cache_read_input_tokens ?? 0;
+                const cacheWrite = body.usage.cache_creation_input_tokens ?? 0;
+                totalInputTokens += nonCachedInput + cacheRead + cacheWrite;
+                totalOutputTokens += body.usage.output_tokens ?? 0;
+                totalCachedInputTokens += cacheRead;
+                totalCacheCreationTokens += cacheWrite;
+            }
+        };
+        const buildUsage = () => ({
+            input_tokens: totalInputTokens,
+            output_tokens: totalOutputTokens,
+            total_tokens: totalInputTokens + totalOutputTokens,
+            api_calls: apiCallCount,
+            provider: 'anthropic',
+            model: this.model,
+            estimated_cost_usd: estimateCost(this.model, totalInputTokens, totalOutputTokens, totalCachedInputTokens, totalCacheCreationTokens),
+            ...(totalCachedInputTokens > 0 ? { cached_input_tokens: totalCachedInputTokens } : {}),
+            ...(totalCacheCreationTokens > 0 ? { cache_creation_input_tokens: totalCacheCreationTokens } : {}),
+        });
+        // Build messages array with optional conversation history
+        const messages = [];
+        if (conversationHistory?.length) {
+            for (const turn of conversationHistory) {
+                messages.push({ role: turn.role, content: turn.content });
+            }
+        }
+        messages.push({ role: 'user', content: userMessage });
+        // Track conversation turns for storage
+        const conversationTurns = [
+            ...(conversationHistory ?? []),
+            { role: 'user', content: userMessage },
+        ];
+        let body = await this.apiCallWithRetry(systemBlocks, messages, tools);
+        accumulateUsage(body);
+        console.error(`[duul] response.id=${body.id} model=${this.model} provider=anthropic`);
+        // Store assistant response
+        conversationTurns.push({ role: 'assistant', content: body.content });
+        // Agentic tool-calling loop
+        if (effectiveRoot) {
+            const toolReadBudget = MAX_INPUT_CHARS - (enhancedSystem.length + userMessage.length);
+            let accumulatedToolChars = 0;
+            const getStrategyLevel = () => {
+                const ratio = accumulatedToolChars / toolReadBudget;
+                if (ratio < 0.5)
+                    return 0;
+                if (ratio < 0.8)
+                    return 1;
+                if (ratio < 1.0)
+                    return 2;
+                return 3;
+            };
+            const isToolAllowed = (toolName, level) => {
+                if (level >= 3)
+                    return false;
+                if (level >= 2)
+                    return SEARCH_ONLY_TOOLS.has(toolName);
+                if (level >= 1)
+                    return !FULL_READ_TOOLS.has(toolName);
+                return true;
+            };
+            const budgetMessage = (toolName, level) => {
+                if (level >= 3)
+                    return 'Budget exhausted. You must produce your final review verdict now with the context you already have.';
+                if (level >= 2)
+                    return `[Budget Level 2] Only search/stat tools allowed. "${toolName}" blocked.`;
+                if (level >= 1)
+                    return `[Budget Level 1] Full file reads blocked. "${toolName}" not allowed. Use read_file_range or search_in_files.`;
+                return '';
+            };
+            const toolCache = new Map();
+            const callCounts = new Map();
+            for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+                const toolUses = body.content.filter((b) => b.type === 'tool_use');
+                if (toolUses.length === 0 || body.stop_reason !== 'tool_use')
+                    break;
+                const strategyLevel = getStrategyLevel();
+                console.error(`[duul] Tool round ${round + 1}: ${toolUses.length} call(s), budget ${accumulatedToolChars}/${toolReadBudget} (level ${strategyLevel})`);
+                const toolResults = [];
+                for (const call of toolUses) {
+                    const args = call.input;
+                    const cacheKey = `${call.name}:${JSON.stringify(args)}`;
+                    const argSummary = (args.path ?? args.query ?? args.prefix ?? '');
+                    const count = (callCounts.get(cacheKey) ?? 0) + 1;
+                    callCounts.set(cacheKey, count);
+                    if (count > MAX_REPEAT_CALLS) {
+                        toolResults.push({ type: 'tool_result', tool_use_id: call.id, content: 'You have already read this content multiple times. Use the context you already have to complete your review.' });
+                        continue;
+                    }
+                    if (toolCache.has(cacheKey)) {
+                        toolResults.push({ type: 'tool_result', tool_use_id: call.id, content: toolCache.get(cacheKey) });
+                        continue;
+                    }
+                    const currentLevel = getStrategyLevel();
+                    if (!isToolAllowed(call.name, currentLevel)) {
+                        toolResults.push({ type: 'tool_result', tool_use_id: call.id, content: budgetMessage(call.name, currentLevel) });
+                        continue;
+                    }
+                    const result = await executeFilesystemTool(effectiveRoot, call.name, args, workspaceScope);
+                    toolCache.set(cacheKey, result);
+                    allUsedTools.push(`${call.name}(${argSummary})`);
+                    accumulatedToolChars += result.length;
+                    console.error(`[duul]   ${call.name}(${argSummary}) -> ${result.length} chars (total: ${accumulatedToolChars}/${toolReadBudget}, level ${getStrategyLevel()})`);
+                    toolResults.push({ type: 'tool_result', tool_use_id: call.id, content: result });
+                }
+                // Append tool results as a user message
+                messages.push({ role: 'assistant', content: body.content });
+                messages.push({ role: 'user', content: toolResults });
+                conversationTurns.push({ role: 'user', content: toolResults });
+                body = await this.apiCallWithRetry(systemBlocks, messages, tools);
+                accumulateUsage(body);
+                conversationTurns.push({ role: 'assistant', content: body.content });
+                console.error(`[duul] response.id=${body.id} (after tool round ${round + 1})`);
+                // Force verdict if budget exhausted
+                if (getStrategyLevel() >= 3) {
+                    const pendingTools = body.content.filter((b) => b.type === 'tool_use');
+                    if (pendingTools.length > 0) {
+                        const stopResults = pendingTools.map((c) => ({
+                            type: 'tool_result',
+                            tool_use_id: c.id,
+                            content: 'No more file reads allowed. You must produce your final review verdict now.',
+                        }));
+                        messages.push({ role: 'assistant', content: body.content });
+                        messages.push({ role: 'user', content: stopResults });
+                        body = await this.apiCallWithRetry(systemBlocks, messages, tools);
+                        accumulateUsage(body);
+                        conversationTurns.push({ role: 'user', content: stopResults });
+                        conversationTurns.push({ role: 'assistant', content: body.content });
+                    }
+                    break;
+                }
+            }
+            // Handle pending tool calls after loop exhaustion
+            const pendingTools = body.content.filter((b) => b.type === 'tool_use');
+            if (pendingTools.length > 0 && body.stop_reason === 'tool_use') {
+                const stopResults = pendingTools.map((c) => ({
+                    type: 'tool_result',
+                    tool_use_id: c.id,
+                    content: 'Tool call limit reached. You must produce your final review verdict now.',
+                }));
+                messages.push({ role: 'assistant', content: body.content });
+                messages.push({ role: 'user', content: stopResults });
+                body = await this.apiCallWithRetry(systemBlocks, messages, tools);
+                accumulateUsage(body);
+                conversationTurns.push({ role: 'user', content: stopResults });
+                conversationTurns.push({ role: 'assistant', content: body.content });
+            }
+        }
+        const usage = buildUsage();
+        const costStr = usage.estimated_cost_usd !== null ? ` (~$${usage.estimated_cost_usd.toFixed(4)})` : '';
+        const cacheParts = [];
+        if (usage.cached_input_tokens)
+            cacheParts.push(`cache_read: ${usage.cached_input_tokens}`);
+        if (usage.cache_creation_input_tokens)
+            cacheParts.push(`cache_write: ${usage.cache_creation_input_tokens}`);
+        const cachedStr = cacheParts.length ? ` [${cacheParts.join(', ')}]` : '';
+        console.error(`[duul] Token usage: ${usage.input_tokens} in + ${usage.output_tokens} out = ${usage.total_tokens} total (${usage.api_calls} API calls)${cachedStr}${costStr}`);
+        // Extract text content and parse JSON
+        const text = body.content.find((c) => c.type === 'text')?.text;
+        if (!text) {
+            if (options.createFallback) {
+                const reason = body.stop_reason === 'tool_use' ? 'round_limit' : 'budget';
+                const fallback = options.createFallback(reason, allUsedTools);
+                console.error(`[duul] Returning structured fallback (reason: ${reason}).`);
+                return { parsed: fallback, reviewId: body.id, usage, conversationTurns };
+            }
+            throw new Error('Anthropic returned no text content');
+        }
+        const jsonStr = extractJson(text);
+        const parsed = outputSchema.parse(JSON.parse(jsonStr));
+        return { parsed, reviewId: body.id, usage, conversationTurns };
+    }
+    async apiCallWithRetry(system, messages, tools) {
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 120_000);
+            try {
+                const response = await fetch(`${this.baseUrl}/v1/messages`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-api-key': this.apiKey,
+                        'anthropic-version': '2023-06-01',
+                    },
+                    body: JSON.stringify({
+                        model: this.model,
+                        max_tokens: 16384,
+                        temperature: this.temperature,
+                        top_p: this.topP,
+                        system,
+                        messages,
+                        ...(tools ? { tools } : {}),
+                    }),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    const status = response.status;
+                    if ((status === 429 || status >= 500) && attempt < MAX_RETRIES - 1) {
+                        const delay = 1000 * Math.pow(2, attempt);
+                        console.error(`[duul] Anthropic retry ${attempt + 1}/${MAX_RETRIES} after ${delay}ms (status ${status})`);
+                        await new Promise((resolve) => setTimeout(resolve, delay));
+                        continue;
+                    }
+                    throw new Error(`Anthropic API error: ${status} ${response.statusText}`);
+                }
+                return await response.json();
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                if (attempt < MAX_RETRIES - 1 && error instanceof Error && error.name === 'AbortError') {
+                    const delay = 1000 * Math.pow(2, attempt);
+                    console.error(`[duul] Anthropic retry ${attempt + 1}/${MAX_RETRIES} after ${delay}ms (timeout)`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new Error('Unreachable: exhausted retries');
+    }
+}
+/**
+ * Minimal zod-to-JSON-schema conversion for the output format instruction.
+ */
+function zodToJsonSchema(schema) {
+    if ('_def' in schema && typeof schema._def === 'object') {
+        const def = schema._def;
+        if (def.typeName === 'ZodObject' && def.shape) {
+            const shape = def.shape();
+            const properties = {};
+            for (const [key, value] of Object.entries(shape)) {
+                const zodField = value;
+                properties[key] = { description: zodField._def?.description ?? key };
+            }
+            return { type: 'object', properties };
+        }
+    }
+    return { type: 'object', description: 'See system prompt for schema details' };
+}
+/**
+ * Extract JSON from a string that may contain markdown code blocks.
+ */
+function extractJson(text) {
+    const codeBlockMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (codeBlockMatch)
+        return codeBlockMatch[1].trim();
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (jsonMatch)
+        return jsonMatch[0];
+    return text.trim();
+}

package/build/services/providers/google.d.ts

@@ -0,0 +1,28 @@
+import type { z } from 'zod';
+import type { ReviewerProvider, ReviewCallOptions, ReviewCallResult, ProviderCapabilities } from './types.js';
+/**
+ * Google provider — uses Gemini models via the Generative Language API.
+ *
+ * Capabilities:
+ * - Tool calling via native functionDeclarations
+ * - JSON mode (responseMimeType: "application/json") when no tools active
+ * - No previous_response_id
+ */
+export declare class GoogleProvider implements ReviewerProvider {
+    readonly name = "google";
+    readonly capabilities: ProviderCapabilities;
+    private apiKey;
+    private baseUrl;
+    private model;
+    private temperature;
+    private topP;
+    constructor(config?: {
+        apiKey?: string;
+        baseUrl?: string;
+        model?: string;
+        temperature?: number;
+        topP?: number;
+    });
+    review<T extends z.ZodType>(options: ReviewCallOptions<T>): Promise<ReviewCallResult<z.infer<T>>>;
+    private apiCallWithRetry;
+}