thaddeus 1.0.18 → 1.0.27

package/src/services/api/xai/anthropic-shim.js

@@ -0,0 +1,885 @@
+// ============================================================
+// ANTHROPIC SDK SHIM FOR xAI/GROK + GEMINI
+// Makes the 500K-line Thaddeus codebase talk to Grok & Gemini
+// by mimicking the Anthropic SDK interface.
+//
+// The entire codebase calls:
+//   anthropic.beta.messages.create(params, options).withResponse()
+//
+// This shim intercepts those calls, converts to OpenAI format,
+// and routes to the appropriate backend:
+//   - Heavy tasks (opus/sonnet) → Grok reasoning model
+//   - Lite tasks (haiku)        → Gemini 2.5 Pro (if key set)
+//                                 → Grok fast model (fallback)
+//
+// Built by Dakota Stewart & Thaddeus | Delphi Labs Inc.
+// ============================================================
+import { randomUUID } from 'crypto';
+import { getAuthToken, getProxyUrl, isAuthenticated, } from '../../thaddeusAuth.js';
+// ============================================================
+// HTML Entity Decoding — xAI/Grok sometimes returns HTML entities
+// in streaming text (' for ', & for &, etc.)
+// ============================================================
+function decodeHtmlEntities(text) {
+    if (!text.includes('&'))
+        return text;
+    return text
+        // Named entities
+        .replace(/&/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        // Decimal numeric entities (&#39; &#8217; etc.)
+        .replace(/&#(\d+);/g, (_m, code) => String.fromCharCode(parseInt(code, 10)))
+        // Hex numeric entities (&#x27; &#x2F; etc.)
+        .replace(/&#x([0-9a-fA-F]+);/g, (_m, hex) => String.fromCharCode(parseInt(hex, 16)));
+}
+/**
+ * Streaming-safe HTML entity decoder.
+ * Buffers trailing partial entities (e.g. `&` or `&#3`) across chunks
+ * so split entities like `I&` + `#39;m` decode correctly.
+ */
+class StreamingEntityDecoder {
+    buffer = '';
+    decode(chunk) {
+        const text = this.buffer + chunk;
+        this.buffer = '';
+        // Check if text ends with a potential partial entity (& followed by incomplete sequence)
+        const lastAmp = text.lastIndexOf('&');
+        if (lastAmp !== -1) {
+            const tail = text.slice(lastAmp);
+            // If the tail looks like a partial entity (& not followed by a complete entity ending in ;)
+            if (!tail.includes(';') && tail.length < 10) {
+                // Buffer the partial entity for the next chunk
+                this.buffer = tail;
+                return decodeHtmlEntities(text.slice(0, lastAmp));
+            }
+        }
+        return decodeHtmlEntities(text);
+    }
+    /** Flush any remaining buffered content (call at stream end) */
+    flush() {
+        const remaining = this.buffer;
+        this.buffer = '';
+        return remaining ? decodeHtmlEntities(remaining) : '';
+    }
+}
+// ============================================================
+// xAI API Configuration
+// ============================================================
+const XAI_BASE_URL = process.env.XAI_BASE_URL || 'https://api.x.ai/v1';
+// ============================================================
+// Message Format Converters
+// ============================================================
+/**
+ * Convert Anthropic system prompt blocks to a single string for xAI
+ */
+function convertSystemPrompt(system) {
+    if (!system)
+        return '';
+    if (typeof system === 'string')
+        return system;
+    if (Array.isArray(system)) {
+        return system
+            .map((block) => {
+            if (typeof block === 'string')
+                return block;
+            if (block.type === 'text')
+                return block.text || '';
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n\n');
+    }
+    return String(system);
+}
+/**
+ * Convert Anthropic messages array to xAI/OpenAI format
+ */
+function convertMessages(messages, system) {
+    const result = [];
+    // System prompt goes first as a system message
+    const sysText = convertSystemPrompt(system);
+    if (sysText) {
+        result.push({ role: 'system', content: sysText });
+    }
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            // User messages can contain text, images, tool_results
+            if (typeof msg.content === 'string') {
+                result.push({ role: 'user', content: msg.content });
+                continue;
+            }
+            if (Array.isArray(msg.content)) {
+                // Check if any blocks are tool_results — these need special handling
+                const toolResults = msg.content.filter((b) => b.type === 'tool_result');
+                const otherBlocks = msg.content.filter((b) => b.type !== 'tool_result');
+                // Non-tool-result blocks become the user message content
+                if (otherBlocks.length > 0) {
+                    const xaiContent = otherBlocks.map((block) => {
+                        if (block.type === 'text')
+                            return { type: 'text', text: block.text || '' };
+                        if (block.type === 'image') {
+                            return {
+                                type: 'image_url',
+                                image_url: {
+                                    url: `data:${block.source?.media_type || 'image/png'};base64,${block.source?.data || ''}`,
+                                    detail: 'auto',
+                                },
+                            };
+                        }
+                        if (block.type === 'document') {
+                            // PDF/document blocks — extract text if available
+                            return { type: 'text', text: `[Document: ${block.source?.media_type || 'unknown'}]` };
+                        }
+                        return { type: 'text', text: JSON.stringify(block) };
+                    });
+                    result.push({ role: 'user', content: xaiContent });
+                }
+                // Tool results become separate tool messages (OpenAI format)
+                for (const tr of toolResults) {
+                    let content = '';
+                    if (typeof tr.content === 'string') {
+                        content = tr.content;
+                    }
+                    else if (Array.isArray(tr.content)) {
+                        content = tr.content.map((b) => b.text || JSON.stringify(b)).join('\n');
+                    }
+                    result.push({
+                        role: 'tool',
+                        tool_call_id: tr.tool_use_id,
+                        content: content || '(empty result)',
+                    });
+                }
+                // If there were ONLY tool results and no other content
+                if (otherBlocks.length === 0 && toolResults.length === 0) {
+                    result.push({ role: 'user', content: '' });
+                }
+            }
+            continue;
+        }
+        if (msg.role === 'assistant') {
+            if (typeof msg.content === 'string') {
+                result.push({ role: 'assistant', content: msg.content });
+                continue;
+            }
+            if (Array.isArray(msg.content)) {
+                const textParts = [];
+                const toolCalls = [];
+                for (const block of msg.content) {
+                    if (block.type === 'text') {
+                        textParts.push(block.text || '');
+                    }
+                    else if (block.type === 'tool_use') {
+                        toolCalls.push({
+                            id: block.id || randomUUID(),
+                            type: 'function',
+                            function: {
+                                name: block.name,
+                                arguments: typeof block.input === 'string'
+                                    ? block.input
+                                    : JSON.stringify(block.input || {}),
+                            },
+                        });
+                    }
+                    else if (block.type === 'thinking') {
+                        // Skip thinking blocks — Grok handles reasoning internally
+                    }
+                }
+                const assistantMsg = {
+                    role: 'assistant',
+                    content: textParts.join('\n') || null,
+                };
+                if (toolCalls.length > 0) {
+                    assistantMsg.tool_calls = toolCalls;
+                }
+                result.push(assistantMsg);
+            }
+            continue;
+        }
+        // Fallback — pass through
+        result.push({
+            role: msg.role,
+            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+        });
+    }
+    return result;
+}
+/**
+ * Convert Anthropic tool definitions to xAI/OpenAI format
+ */
+function convertTools(tools) {
+    if (!tools || tools.length === 0)
+        return [];
+    return tools.map((tool) => {
+        // Handle BetaToolUnion — can be computer_use, text_editor, bash, or custom
+        if (tool.type === 'computer_20241022' || tool.type === 'text_editor_20241022' || tool.type === 'bash_20241022') {
+            // Server-side tools — convert to function format
+            return {
+                type: 'function',
+                function: {
+                    name: tool.name || tool.type,
+                    description: `Anthropic ${tool.type} tool`,
+                    parameters: { type: 'object', properties: {} },
+                },
+            };
+        }
+        // Standard custom tool
+        return {
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description || '',
+                parameters: tool.input_schema || {},
+            },
+        };
+    });
+}
+/**
+ * Convert Anthropic tool_choice to xAI format
+ */
+function convertToolChoice(toolChoice) {
+    if (!toolChoice)
+        return undefined;
+    if (toolChoice.type === 'auto')
+        return 'auto';
+    if (toolChoice.type === 'none')
+        return 'none';
+    if (toolChoice.type === 'any')
+        return 'required';
+    if (toolChoice.type === 'tool') {
+        return { type: 'function', function: { name: toolChoice.name } };
+    }
+    return 'auto';
+}
+// ============================================================
+// Streaming Event Converter
+// Converts xAI SSE events to Anthropic BetaRawMessageStreamEvent format
+// ============================================================
+class XAIToAnthropicStreamAdapter {
+    messageId;
+    model;
+    activeContentBlocks = new Map();
+    textBlockIndex = 0;
+    toolBlockIndices = new Map(); // xAI tool index → our block index
+    nextBlockIndex = 0;
+    textBlockStarted = false;
+    finishReason = null;
+    entityDecoder = new StreamingEntityDecoder();
+    constructor(model) {
+        this.messageId = `msg_${randomUUID().replace(/-/g, '').slice(0, 24)}`;
+        this.model = model;
+    }
+    /**
+     * Convert a single xAI stream event to zero or more Anthropic events
+     */
+    *convert(xaiEvent) {
+        const choice = xaiEvent.choices?.[0];
+        if (!choice)
+            return;
+        // First event — emit message_start
+        if (choice.delta.role === 'assistant') {
+            yield {
+                type: 'message_start',
+                message: {
+                    id: this.messageId,
+                    type: 'message',
+                    role: 'assistant',
+                    content: [],
+                    model: xaiEvent.model || this.model,
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: {
+                        input_tokens: 0,
+                        output_tokens: 0,
+                        cache_creation_input_tokens: 0,
+                        cache_read_input_tokens: 0,
+                    },
+                },
+            };
+        }
+        // Text content
+        if (choice.delta.content) {
+            if (!this.textBlockStarted) {
+                this.textBlockStarted = true;
+                this.textBlockIndex = this.nextBlockIndex++;
+                yield {
+                    type: 'content_block_start',
+                    index: this.textBlockIndex,
+                    content_block: { type: 'text', text: '' },
+                };
+            }
+            // Use streaming decoder to handle entities split across chunks
+            const decoded = this.entityDecoder.decode(choice.delta.content);
+            if (decoded) {
+                yield {
+                    type: 'content_block_delta',
+                    index: this.textBlockIndex,
+                    delta: { type: 'text_delta', text: decoded },
+                };
+            }
+        }
+        // Tool calls
+        if (choice.delta.tool_calls) {
+            for (const tc of choice.delta.tool_calls) {
+                if (tc.id) {
+                    // New tool call starting — flush decoder & close text block if open
+                    if (this.textBlockStarted && !this.activeContentBlocks.has(-1)) {
+                        const flushed = this.entityDecoder.flush();
+                        if (flushed) {
+                            yield {
+                                type: 'content_block_delta',
+                                index: this.textBlockIndex,
+                                delta: { type: 'text_delta', text: flushed },
+                            };
+                        }
+                        yield { type: 'content_block_stop', index: this.textBlockIndex };
+                        this.activeContentBlocks.set(-1, { type: 'text_closed' });
+                    }
+                    const blockIndex = this.nextBlockIndex++;
+                    this.toolBlockIndices.set(tc.index, blockIndex);
+                    const toolUseId = tc.id;
+                    yield {
+                        type: 'content_block_start',
+                        index: blockIndex,
+                        content_block: {
+                            type: 'tool_use',
+                            id: toolUseId,
+                            name: tc.function?.name || '',
+                            input: {},
+                        },
+                    };
+                    this.activeContentBlocks.set(tc.index, {
+                        type: 'tool_use',
+                        name: tc.function?.name,
+                        id: toolUseId,
+                    });
+                    // If there are initial arguments, emit them
+                    if (tc.function?.arguments) {
+                        yield {
+                            type: 'content_block_delta',
+                            index: blockIndex,
+                            delta: { type: 'input_json_delta', partial_json: tc.function.arguments },
+                        };
+                    }
+                }
+                else if (tc.function?.arguments) {
+                    // Continuation of arguments for existing tool call
+                    const blockIndex = this.toolBlockIndices.get(tc.index);
+                    if (blockIndex !== undefined) {
+                        yield {
+                            type: 'content_block_delta',
+                            index: blockIndex,
+                            delta: { type: 'input_json_delta', partial_json: tc.function.arguments },
+                        };
+                    }
+                }
+            }
+        }
+        // Finish
+        if (choice.finish_reason) {
+            this.finishReason = choice.finish_reason;
+            // Flush any buffered partial entity before closing text block
+            if (this.textBlockStarted && !this.activeContentBlocks.has(-1)) {
+                const flushed = this.entityDecoder.flush();
+                if (flushed) {
+                    yield {
+                        type: 'content_block_delta',
+                        index: this.textBlockIndex,
+                        delta: { type: 'text_delta', text: flushed },
+                    };
+                }
+                yield { type: 'content_block_stop', index: this.textBlockIndex };
+            }
+            // Close any open tool blocks
+            for (const [xaiIdx, blockIdx] of this.toolBlockIndices) {
+                yield { type: 'content_block_stop', index: blockIdx };
+            }
+            // Map finish_reason
+            const stopReason = choice.finish_reason === 'tool_calls'
+                ? 'tool_use'
+                : choice.finish_reason === 'stop'
+                    ? 'end_turn'
+                    : choice.finish_reason === 'length'
+                        ? 'max_tokens'
+                        : 'end_turn';
+            yield {
+                type: 'message_delta',
+                delta: { stop_reason: stopReason, stop_sequence: null },
+                usage: {
+                    output_tokens: xaiEvent.usage?.completion_tokens || 0,
+                },
+            };
+            yield { type: 'message_stop' };
+        }
+    }
+    /**
+     * Handle the final usage event (xAI sends usage in last event with stream_options)
+     */
+    *convertUsage(xaiEvent) {
+        if (xaiEvent.usage && !xaiEvent.choices?.[0]?.finish_reason) {
+            // Usage-only event (sent after [DONE] with stream_options.include_usage)
+            // We already emitted message_delta with usage in the finish event
+        }
+    }
+}
+// ============================================================
+// XAI Streaming Response — Mimics Anthropic SDK's Stream class
+// ============================================================
+class XAIAnthropicStream {
+    // Fixed April 2, 2026: was private — withResponse() couldn't access it,
+    // returned dummy Response, request_id was random UUID
+    response;
+    model;
+    _controller;
+    controller;
+    constructor(response, model, controller) {
+        this.response = response;
+        this.model = model;
+        this._controller = controller;
+        this.controller = controller;
+    }
+    async *[Symbol.asyncIterator]() {
+        const reader = this.response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const decoder = new TextDecoder();
+        const adapter = new XAIToAnthropicStreamAdapter(this.model);
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed === 'data: [DONE]')
+                        continue;
+                    if (!trimmed.startsWith('data: '))
+                        continue;
+                    try {
+                        const xaiEvent = JSON.parse(trimmed.slice(6));
+                        for (const anthropicEvent of adapter.convert(xaiEvent)) {
+                            yield anthropicEvent;
+                        }
+                    }
+                    catch {
+                        // Skip malformed SSE lines
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Mimics Anthropic SDK's .withResponse() — returns the stream + metadata
+     */
+    withResponse() {
+        return {
+            data: this,
+            response: this.response,
+            request_id: this.response.headers.get('x-request-id') || randomUUID(),
+        };
+    }
+}
+// ============================================================
+// Non-Streaming Response Converter
+// ============================================================
+function convertNonStreamingResponse(xaiResponse) {
+    const choice = xaiResponse.choices?.[0];
+    if (!choice)
+        throw new Error('No response choices from xAI');
+    const content = [];
+    if (choice.message.content) {
+        content.push({ type: 'text', text: decodeHtmlEntities(choice.message.content) });
+    }
+    if (choice.message.tool_calls) {
+        for (const tc of choice.message.tool_calls) {
+            let parsedInput = {};
+            try {
+                parsedInput = JSON.parse(tc.function.arguments || '{}');
+            }
+            catch {
+                parsedInput = {};
+            }
+            content.push({
+                type: 'tool_use',
+                id: tc.id || randomUUID(),
+                name: tc.function.name,
+                input: parsedInput,
+            });
+        }
+    }
+    return {
+        id: xaiResponse.id || `msg_${randomUUID().replace(/-/g, '').slice(0, 24)}`,
+        type: 'message',
+        role: 'assistant',
+        content,
+        model: xaiResponse.model,
+        stop_reason: choice.finish_reason === 'tool_calls'
+            ? 'tool_use'
+            : choice.finish_reason === 'stop'
+                ? 'end_turn'
+                : choice.finish_reason || 'end_turn',
+        stop_sequence: null,
+        usage: {
+            input_tokens: xaiResponse.usage?.prompt_tokens || 0,
+            output_tokens: xaiResponse.usage?.completion_tokens || 0,
+            cache_creation_input_tokens: 0,
+            cache_read_input_tokens: 0,
+        },
+    };
+}
+// ============================================================
+// XAI ANTHROPIC SHIM — The main class
+// Returned by getAnthropicClient() when THADDEUS_USE_XAI=true
+// ============================================================
+export class XAIAnthropicShim {
+    apiKey;
+    baseUrl;
+    model;
+    fastModel;
+    geminiApiKey;
+    geminiBaseUrl;
+    geminiModel;
+    defaultHeaders;
+    timeout;
+    // Mimic Anthropic SDK structure
+    beta;
+    // Also provide top-level messages for non-beta calls
+    messages;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || XAI_BASE_URL;
+        this.model = config.model || process.env.GROK_REASONING_MODEL || 'grok-4.20-0309';
+        this.fastModel = config.fastModel || process.env.GROK_FAST_MODEL || 'grok-4-1-fast-non-reasoning';
+        this.geminiApiKey = config.geminiApiKey || process.env.GEMINI_API_KEY || process.env.GOOGLE_AI_API_KEY || '';
+        this.geminiBaseUrl = config.geminiBaseUrl || process.env.GEMINI_BASE_URL || 'https://generativelanguage.googleapis.com/v1beta/openai';
+        this.geminiModel = config.geminiModel || process.env.GEMINI_MODEL || 'gemini-2.5-pro';
+        this.defaultHeaders = config.defaultHeaders || {};
+        this.timeout = config.timeout || 600_000;
+        // Wire up the beta.messages.create interface
+        // CRITICAL: The Anthropic SDK returns an APIPromise from create().
+        // Code calls: create({stream:true}).withResponse()
+        // So create() must return an object with .withResponse() AND be thenable.
+        const self = this;
+        const makeAPIPromise = (params, options) => {
+            const innerPromise = self._create(params, options);
+            // Create a thenable with .withResponse()
+            const apiPromise = {
+                then: (resolve, reject) => innerPromise.then(resolve, reject),
+                catch: (reject) => innerPromise.catch(reject),
+                finally: (fn) => innerPromise.finally(fn),
+                [Symbol.toStringTag]: 'Promise',
+                withResponse: () => innerPromise.then((data) => ({
+                    data,
+                    response: data?.response || new Response(null, { status: 200 }),
+                    request_id: data?.response?.headers?.get?.('x-request-id') || randomUUID(),
+                })),
+            };
+            return apiPromise;
+        };
+        this.beta = {
+            messages: {
+                create: makeAPIPromise,
+            },
+        };
+        this.messages = {
+            create: makeAPIPromise,
+        };
+    }
+    /**
+     * Main create method — handles both streaming and non-streaming
+     * Returns either a Stream (with .withResponse()) or a BetaMessage
+     */
+    async _create(params, options) {
+        // ================================================================
+        // Thaddeus Proxy Auth Gate
+        // If no direct xAI API key but user has an auth token,
+        // route through the Render proxy with subscription verification.
+        // This is the ONLY place auth is checked — startup is never blocked.
+        // ================================================================
+        const useProxy = this._shouldUseProxy();
+        if (useProxy) {
+            return this._createViaProxy(params, options);
+        }
+        // ================================================================
+        // Direct API path (user has their own xAI key)
+        // ================================================================
+        return this._createDirect(params, options);
+    }
+    /**
+     * Determine whether to use the Render proxy or direct API.
+     * Proxy is used when:
+     *   - No direct xAI API key is set (or it's a placeholder)
+     *   - User has a Thaddeus auth token
+     *   - THADDEUS_USE_PROXY env var is set
+     */
+    _shouldUseProxy() {
+        // Explicit proxy mode
+        if (process.env.THADDEUS_USE_PROXY === '1' || process.env.THADDEUS_USE_PROXY === 'true') {
+            return true;
+        }
+        // If we have a real xAI API key, use direct
+        if (this.apiKey && this.apiKey.length > 10 && !this.apiKey.startsWith('placeholder')) {
+            return false;
+        }
+        // No direct key — use proxy if authenticated
+        return isAuthenticated();
+    }
+    /**
+     * Route through Render proxy with auth token.
+     * Handles auth errors with helpful user-facing messages.
+     */
+    async _createViaProxy(params, options) {
+        const authToken = getAuthToken();
+        if (!authToken) {
+            // No auth token — return a helpful error as if the model responded
+            const { APIError } = await import('@anthropic-ai/sdk');
+            throw new APIError(401, {
+                message: 'Thaddeus requires authentication. Run `thaddeus login` or use /login to sign in with your Delphi Labs subscription.',
+            }, 'Authentication required — run `thaddeus login`', new Headers());
+        }
+        const requestModel = this._resolveModel(params.model);
+        // Convert Anthropic format to xAI format
+        const xaiMessages = convertMessages(params.messages || [], params.system);
+        const xaiTools = convertTools(params.tools || []);
+        const xaiToolChoice = convertToolChoice(params.tool_choice);
+        // Build proxy request body (matches ThaddeusChatRequest schema)
+        const body = {
+            model: requestModel,
+            messages: xaiMessages,
+            temperature: params.temperature ?? 0.7,
+            max_tokens: params.max_tokens || 16384,
+            stream: !!params.stream,
+        };
+        if (xaiTools.length > 0) {
+            body.tools = xaiTools;
+            body.tool_choice = xaiToolChoice || 'auto';
+        }
+        // Auth goes in the header — NEVER in the body for proxy requests
+        const proxyUrl = getProxyUrl();
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${authToken}`,
+            'User-Agent': 'Thaddeus/1.0.0 (Proxy)',
+            'X-Request-Id': randomUUID(),
+            ...this.defaultHeaders,
+            ...(options?.headers || {}),
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        if (options?.signal) {
+            options.signal.addEventListener('abort', () => controller.abort());
+        }
+        try {
+            const response = await fetch(proxyUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            // Handle auth-specific errors from the proxy
+            if (response.status === 401) {
+                const errorBody = await response.text();
+                let parsed;
+                try {
+                    parsed = JSON.parse(errorBody);
+                }
+                catch { /* ignore */ }
+                const errorMsg = parsed?.error || 'Subscription expired or invalid';
+                const code = parsed?.code || 'SUBSCRIPTION_INVALID';
+                const { APIError } = await import('@anthropic-ai/sdk');
+                if (code === 'AUTH_REQUIRED') {
+                    throw new APIError(401, { message: `Authentication required. Run \`thaddeus login\` to sign in.` }, 'Authentication required', new Headers(Object.fromEntries(response.headers.entries())));
+                }
+                throw new APIError(401, { message: `Subscription issue: ${errorMsg}. Visit https://the-oracleai.com/pricing.html to subscribe.` }, errorMsg, new Headers(Object.fromEntries(response.headers.entries())));
+            }
+            if (!response.ok) {
+                const errorBody = await response.text();
+                const { APIError } = await import('@anthropic-ai/sdk');
+                throw new APIError(response.status, { message: `Thaddeus proxy error ${response.status}: ${errorBody}` }, `Thaddeus proxy error ${response.status}: ${errorBody}`, new Headers(Object.fromEntries(response.headers.entries())));
+            }
+            if (params.stream) {
+                return new XAIAnthropicStream(response, requestModel, controller);
+            }
+            else {
+                const data = await response.json();
+                return convertNonStreamingResponse(data);
+            }
+        }
+        catch (err) {
+            clearTimeout(timeoutId);
+            if (err.name === 'AbortError') {
+                if (options?.signal?.aborted) {
+                    throw err;
+                }
+                const { APIError } = await import('@anthropic-ai/sdk');
+                throw new APIError(408, { message: 'Thaddeus proxy request timed out' }, 'Thaddeus proxy request timed out', new Headers());
+            }
+            throw err;
+        }
+    }
+    /**
+     * Direct API call to xAI/Gemini (user has their own API key).
+     * Original code path — unchanged from before auth was added.
+     */
+    async _createDirect(params, options) {
+        // Pick model — use the one from params, or auto-select
+        const requestModel = this._resolveModel(params.model);
+        // Convert Anthropic format to xAI format
+        const xaiMessages = convertMessages(params.messages || [], params.system);
+        const xaiTools = convertTools(params.tools || []);
+        const xaiToolChoice = convertToolChoice(params.tool_choice);
+        // Route to Gemini or xAI based on model
+        const isGemini = this._isGeminiModel(requestModel);
+        const body = {
+            model: requestModel,
+            messages: xaiMessages,
+            temperature: params.temperature ?? 0.7,
+            stream: !!params.stream,
+        };
+        // Gemini 2.5 Pro is a thinking model — max_tokens gets consumed by
+        // internal reasoning, leaving nothing for actual output. Must use
+        // max_completion_tokens which covers thinking + output together.
+        if (isGemini) {
+            body.max_completion_tokens = params.max_tokens || 16384;
+        }
+        else {
+            body.max_tokens = params.max_tokens || 16384;
+        }
+        if (xaiTools.length > 0) {
+            body.tools = xaiTools;
+            body.tool_choice = xaiToolChoice || 'auto';
+        }
+        if (params.stream) {
+            body.stream_options = { include_usage: true };
+        }
+        const targetBaseUrl = isGemini ? this.geminiBaseUrl : this.baseUrl;
+        const targetApiKey = isGemini ? this.geminiApiKey : this.apiKey;
+        // Build headers
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${targetApiKey}`,
+            'User-Agent': 'Thaddeus/1.0.0 (xAI-Bridge)',
+            'X-Request-Id': randomUUID(),
+            ...this.defaultHeaders,
+            ...(options?.headers || {}),
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        // Merge abort signals
+        if (options?.signal) {
+            options.signal.addEventListener('abort', () => controller.abort());
+        }
+        try {
+            const response = await fetch(`${targetBaseUrl}/chat/completions`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorBody = await response.text();
+                const provider = isGemini ? 'Gemini' : 'xAI';
+                // Fixed April 2, 2026: throw APIError-shaped errors so withRetry.ts
+                // can detect 429/500/502/503 and retry instead of crashing immediately.
+                // The retry loop checks `error instanceof APIError` — we import and use it.
+                const { APIError } = await import('@anthropic-ai/sdk');
+                const apiError = new APIError(response.status, { message: `${provider} API error ${response.status}: ${errorBody}` }, `${provider} API error ${response.status}: ${errorBody}`, new Headers(Object.fromEntries(response.headers.entries())));
+                throw apiError;
+            }
+            if (params.stream) {
+                // Return a stream object that mimics Anthropic SDK's stream
+                return new XAIAnthropicStream(response, requestModel, controller);
+            }
+            else {
+                // Non-streaming — parse and convert
+                const data = await response.json();
+                return convertNonStreamingResponse(data);
+            }
+        }
+        catch (err) {
+            clearTimeout(timeoutId);
+            if (err.name === 'AbortError') {
+                // Check if this was a user-initiated abort (Ctrl+C) vs timeout
+                if (options?.signal?.aborted) {
+                    // User abort — re-throw as-is so caller knows it's intentional
+                    throw err;
+                }
+                const provider = isGemini ? 'Gemini' : 'xAI';
+                const { APIError } = await import('@anthropic-ai/sdk');
+                throw new APIError(408, { message: `${provider} API request timed out` }, `${provider} API request timed out`, new Headers());
+            }
+            throw err;
+        }
+    }
+    /**
+     * Resolve which model to use based on the Anthropic model name.
+     * Returns 'gemini-*' prefix when Gemini is configured for fast/lite tasks.
+     */
+    _resolveModel(anthropicModel) {
+        if (!anthropicModel)
+            return this.model;
+        // If it's already a Grok model, pass through
+        if (anthropicModel.startsWith('grok'))
+            return anthropicModel;
+        // If it's already a Gemini model, pass through
+        if (anthropicModel.startsWith('gemini'))
+            return anthropicModel;
+        // Map Anthropic models to backend equivalents
+        const lower = anthropicModel.toLowerCase();
+        if (lower.includes('opus') || lower.includes('sonnet')) {
+            return this.model; // Use reasoning model for heavy models
+        }
+        if (lower.includes('haiku')) {
+            // Route lite/fast tasks to Gemini when API key is available
+            if (this.geminiApiKey) {
+                return this.geminiModel;
+            }
+            return this.fastModel; // Fallback to Grok fast model
+        }
+        return this.model;
+    }
+    /**
+     * Check if a resolved model should be routed to Gemini
+     */
+    _isGeminiModel(model) {
+        return model.startsWith('gemini') && !!this.geminiApiKey;
+    }
+}
+// ============================================================
+// Factory — creates the shim with current env config
+// ============================================================
+export function createXAIAnthropicShim(overrides) {
+    const apiKey = overrides?.apiKey || process.env.XAI_API_KEY;
+    // When using proxy mode, API key is not required — auth token is used instead.
+    // The proxy holds the real xAI key server-side.
+    // If THADDEUS_USE_PROXY is set, skip this check — proxy will return proper auth errors.
+    if (!apiKey && !isAuthenticated() && process.env.THADDEUS_USE_PROXY !== 'true' && process.env.THADDEUS_USE_PROXY !== '1') {
+        throw new Error('No API key or auth token found.\n'
+            + 'Either set XAI_API_KEY in your environment,\n'
+            + 'or run `thaddeus login` to authenticate with your Delphi Labs subscription.');
+    }
+    return new XAIAnthropicShim({
+        // Pass empty string for apiKey when using proxy — _shouldUseProxy() will detect this
+        apiKey: apiKey || '',
+        model: process.env.GROK_REASONING_MODEL || 'grok-4.20-0309',
+        fastModel: process.env.GROK_FAST_MODEL || 'grok-4-1-fast-non-reasoning',
+        baseUrl: process.env.XAI_BASE_URL || 'https://api.x.ai/v1',
+        geminiApiKey: process.env.GEMINI_API_KEY || process.env.GOOGLE_AI_API_KEY || '',
+        geminiBaseUrl: process.env.GEMINI_BASE_URL || 'https://generativelanguage.googleapis.com/v1beta/openai',
+        geminiModel: process.env.GEMINI_MODEL || 'gemini-2.5-pro',
+        defaultHeaders: overrides?.defaultHeaders,
+        timeout: overrides?.timeout || 600_000,
+    });
+}