codemaxxing 0.1.8 → 0.1.9

package/README.md

@@ -40,6 +40,12 @@ curl -fsSL -o %TEMP%\install-codemaxxing.bat https://raw.githubusercontent.com/M
 npm install -g codemaxxing
 ```
 
+## Updating
+
+```bash
+npm update -g codemaxxing
+```
+
 ## Quick Start
 
 ### 1. Start Your LLM
@@ -61,6 +67,39 @@ That's it. Codemaxxing auto-detects LM Studio and connects. Start coding.
 
 ---
 
+## Authentication
+
+**One command to connect any provider:**
+
+```bash
+codemaxxing login
+```
+
+Interactive setup walks you through it. Or use `/login` inside the TUI.
+
+**Supported auth methods:**
+
+| Provider | Methods |
+|----------|---------|
+| **OpenRouter** | OAuth (browser login) or API key — one login, 200+ models |
+| **Anthropic** | Link your Claude subscription (via Claude Code) or API key |
+| **OpenAI** | Import from Codex CLI or API key |
+| **Qwen** | Import from Qwen CLI or API key |
+| **GitHub Copilot** | Device flow (browser) |
+| **Google Gemini** | API key |
+| **Any provider** | API key + custom base URL |
+
+```bash
+codemaxxing login              # Interactive provider picker
+codemaxxing auth list          # See saved credentials
+codemaxxing auth remove <name> # Delete a credential
+codemaxxing auth openrouter    # Direct OpenRouter OAuth
+```
+
+Credentials stored securely in `~/.codemaxxing/auth.json` (owner-only permissions).
+
+---
+
 ## Advanced Setup
 
 **With a remote provider (OpenAI, OpenRouter, etc.):**
@@ -106,6 +145,9 @@ Switch models mid-session without restarting:
 - `/model gpt-4o` — switch to a different model
 - `/models` — list available models from your provider
 
+### 🔐 Authentication
+One command to connect any LLM provider. OpenRouter OAuth (browser login for 200+ models), Anthropic subscription linking, Codex/Qwen CLI import, GitHub Copilot device flow, or manual API keys. Use `codemaxxing login` or `/login` in-session.
+
 ### 📋 Smart Paste
 Paste large code blocks without breaking the UI. Multi-line pastes collapse into `[Pasted text #1 +N lines]` badges (like Claude Code).
 
@@ -117,6 +159,7 @@ Type `/` for autocomplete suggestions. Arrow keys to navigate, Tab or Enter to s
 | Command | Description |
 |---------|-------------|
 | `/help` | Show all commands |
+| `/login` | Interactive auth setup |
 | `/model <name>` | Switch model mid-session |
 | `/models` | List available models |
 | `/map` | Show repository map |

package/dist/agent.d.ts

@@ -8,12 +8,16 @@ export interface AgentOptions {
     onToolCall?: (name: string, args: Record<string, unknown>) => void;
     onToolResult?: (name: string, result: string) => void;
     onThinking?: (text: string) => void;
-    onToolApproval?: (name: string, args: Record<string, unknown>) => Promise<"yes" | "no" | "always">;
+    onToolApproval?: (name: string, args: Record<string, unknown>, diff?: string) => Promise<"yes" | "no" | "always">;
     onGitCommit?: (message: string) => void;
+    onContextCompressed?: (oldTokens: number, newTokens: number) => void;
+    contextCompressionThreshold?: number;
 }
 export declare class CodingAgent {
     private options;
     private client;
+    private anthropicClient;
+    private providerType;
     private messages;
     private tools;
     private cwd;
@@ -25,6 +29,11 @@ export declare class CodingAgent {
     private autoCommitEnabled;
     private repoMap;
     private sessionId;
+    private totalPromptTokens;
+    private totalCompletionTokens;
+    private totalCost;
+    private systemPrompt;
+    private compressionThreshold;
     constructor(options: AgentOptions);
     /**
      * Initialize the agent — call this after constructor to build async context
@@ -49,6 +58,18 @@ export declare class CodingAgent {
      * and loops until the model responds with text (no more tool calls).
      */
     chat(userMessage: string): Promise<string>;
+    /**
+     * Convert OpenAI-format tools to Anthropic tool format
+     */
+    private getAnthropicTools;
+    /**
+     * Convert messages to Anthropic format (separate system from conversation)
+     */
+    private getAnthropicMessages;
+    /**
+     * Anthropic-native streaming chat
+     */
+    private chatAnthropic;
     /**
      * Switch to a different model mid-session
      */
@@ -61,5 +82,14 @@ export declare class CodingAgent {
      * Estimate token count across all messages (~4 chars per token)
      */
     estimateTokens(): number;
+    /**
+     * Check if context needs compression and compress if threshold exceeded
+     */
+    private maybeCompressContext;
+    getCostInfo(): {
+        promptTokens: number;
+        completionTokens: number;
+        totalCost: number;
+    };
     reset(): void;
 }

package/dist/agent.js

@@ -1,13 +1,60 @@
 import OpenAI from "openai";
-import { FILE_TOOLS, executeTool } from "./tools/files.js";
+import Anthropic from "@anthropic-ai/sdk";
+import { FILE_TOOLS, executeTool, generateDiff, getExistingContent } from "./tools/files.js";
 import { buildProjectContext, getSystemPrompt } from "./utils/context.js";
 import { isGitRepo, autoCommit } from "./utils/git.js";
-import { createSession, saveMessage, updateTokenEstimate, loadMessages } from "./utils/sessions.js";
+import { createSession, saveMessage, updateTokenEstimate, updateSessionCost, loadMessages } from "./utils/sessions.js";
 // Tools that can modify your project — require approval
 const DANGEROUS_TOOLS = new Set(["write_file", "run_command"]);
+// Cost per 1M tokens (input/output) for common models
+const MODEL_COSTS = {
+    // OpenAI
+    "gpt-4o": { input: 2.5, output: 10 },
+    "gpt-4o-mini": { input: 0.15, output: 0.6 },
+    "gpt-4-turbo": { input: 10, output: 30 },
+    "gpt-4": { input: 30, output: 60 },
+    "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+    "o1": { input: 15, output: 60 },
+    "o1-mini": { input: 3, output: 12 },
+    "o3-mini": { input: 1.1, output: 4.4 },
+    // Anthropic
+    "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+    "claude-3-5-sonnet": { input: 3, output: 15 },
+    "claude-sonnet-4-20250514": { input: 3, output: 15 },
+    "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
+    "claude-3-opus-20240229": { input: 15, output: 75 },
+    "claude-3-haiku-20240307": { input: 0.25, output: 1.25 },
+    // Qwen (typically free/cheap on local, but OpenRouter pricing)
+    "qwen/qwen-2.5-coder-32b-instruct": { input: 0.2, output: 0.2 },
+    "qwen/qwen-2.5-72b-instruct": { input: 0.35, output: 0.4 },
+    // DeepSeek
+    "deepseek/deepseek-chat": { input: 0.14, output: 0.28 },
+    "deepseek/deepseek-coder": { input: 0.14, output: 0.28 },
+    // Llama
+    "meta-llama/llama-3.1-70b-instruct": { input: 0.52, output: 0.75 },
+    "meta-llama/llama-3.1-8b-instruct": { input: 0.055, output: 0.055 },
+    // Google
+    "google/gemini-pro-1.5": { input: 1.25, output: 5 },
+    "google/gemini-flash-1.5": { input: 0.075, output: 0.3 },
+};
+function getModelCost(model) {
+    // Direct match
+    if (MODEL_COSTS[model])
+        return MODEL_COSTS[model];
+    // Partial match (model name contains a known key)
+    const lower = model.toLowerCase();
+    for (const [key, cost] of Object.entries(MODEL_COSTS)) {
+        if (lower.includes(key) || key.includes(lower))
+            return cost;
+    }
+    // Default: $0 (local/unknown models)
+    return { input: 0, output: 0 };
+}
 export class CodingAgent {
     options;
     client;
+    anthropicClient = null;
+    providerType;
     messages = [];
     tools = FILE_TOOLS;
     cwd;
@@ -19,26 +66,42 @@ export class CodingAgent {
     autoCommitEnabled = false;
     repoMap = "";
     sessionId = "";
+    totalPromptTokens = 0;
+    totalCompletionTokens = 0;
+    totalCost = 0;
+    systemPrompt = "";
+    compressionThreshold;
     constructor(options) {
         this.options = options;
+        this.providerType = options.provider.type || "openai";
         this.client = new OpenAI({
             baseURL: options.provider.baseUrl,
             apiKey: options.provider.apiKey,
         });
+        if (this.providerType === "anthropic") {
+            this.anthropicClient = new Anthropic({
+                apiKey: options.provider.apiKey,
+            });
+        }
         this.cwd = options.cwd;
         this.maxTokens = options.maxTokens;
         this.autoApprove = options.autoApprove;
         this.model = options.provider.model;
+        // Default model for Anthropic
+        if (this.providerType === "anthropic" && (this.model === "auto" || !this.model)) {
+            this.model = "claude-sonnet-4-20250514";
+        }
         this.gitEnabled = isGitRepo(this.cwd);
+        this.compressionThreshold = options.contextCompressionThreshold ?? 80000;
     }
     /**
      * Initialize the agent — call this after constructor to build async context
      */
     async init() {
         const context = await buildProjectContext(this.cwd);
-        const systemPrompt = await getSystemPrompt(context);
+        this.systemPrompt = await getSystemPrompt(context);
         this.messages = [
-            { role: "system", content: systemPrompt },
+            { role: "system", content: this.systemPrompt },
         ];
         // Create a new session
         this.sessionId = createSession(this.cwd, this.model);
@@ -81,6 +144,11 @@ export class CodingAgent {
         const userMsg = { role: "user", content: userMessage };
         this.messages.push(userMsg);
         saveMessage(this.sessionId, userMsg);
+        // Check if context needs compression before sending
+        await this.maybeCompressContext();
+        if (this.providerType === "anthropic" && this.anthropicClient) {
+            return this.chatAnthropic(userMessage);
+        }
         let iterations = 0;
         const MAX_ITERATIONS = 20;
         while (iterations < MAX_ITERATIONS) {
@@ -91,13 +159,21 @@ export class CodingAgent {
                 tools: this.tools,
                 max_tokens: this.maxTokens,
                 stream: true,
+                stream_options: { include_usage: true },
             });
             // Accumulate the streamed response
             let contentText = "";
             let thinkingText = "";
             let inThinking = false;
             const toolCalls = new Map();
+            let chunkPromptTokens = 0;
+            let chunkCompletionTokens = 0;
             for await (const chunk of stream) {
+                // Capture usage from the final chunk
+                if (chunk.usage) {
+                    chunkPromptTokens = chunk.usage.prompt_tokens ?? 0;
+                    chunkCompletionTokens = chunk.usage.completion_tokens ?? 0;
+                }
                 const delta = chunk.choices?.[0]?.delta;
                 if (!delta)
                     continue;
@@ -154,6 +230,15 @@ export class CodingAgent {
             }
             this.messages.push(assistantMessage);
             saveMessage(this.sessionId, assistantMessage);
+            // Track token usage and cost
+            if (chunkPromptTokens > 0 || chunkCompletionTokens > 0) {
+                this.totalPromptTokens += chunkPromptTokens;
+                this.totalCompletionTokens += chunkCompletionTokens;
+                const costs = getModelCost(this.model);
+                this.totalCost = (this.totalPromptTokens / 1_000_000) * costs.input +
+                    (this.totalCompletionTokens / 1_000_000) * costs.output;
+                updateSessionCost(this.sessionId, this.totalPromptTokens, this.totalCompletionTokens, this.totalCost);
+            }
             // If no tool calls, we're done — return the text
             if (toolCalls.size === 0) {
                 updateTokenEstimate(this.sessionId, this.estimateTokens());
@@ -172,7 +257,15 @@ export class CodingAgent {
                 // Check approval for dangerous tools
                 if (DANGEROUS_TOOLS.has(toolCall.name) && !this.autoApprove && !this.alwaysApproved.has(toolCall.name)) {
                     if (this.options.onToolApproval) {
-                        const decision = await this.options.onToolApproval(toolCall.name, args);
+                        // Generate diff for write_file if file already exists
+                        let diff;
+                        if (toolCall.name === "write_file" && args.path && args.content) {
+                            const existing = getExistingContent(String(args.path), this.cwd);
+                            if (existing !== null) {
+                                diff = generateDiff(existing, String(args.content), String(args.path));
+                            }
+                        }
+                        const decision = await this.options.onToolApproval(toolCall.name, args, diff);
                         if (decision === "no") {
                             const denied = `Tool call "${toolCall.name}" was denied by the user.`;
                             this.options.onToolResult?.(toolCall.name, denied);
@@ -213,6 +306,185 @@ export class CodingAgent {
         }
         return "Max iterations reached. The agent may be stuck in a loop.";
     }
+    /**
+     * Convert OpenAI-format tools to Anthropic tool format
+     */
+    getAnthropicTools() {
+        return this.tools.map((t) => ({
+            name: t.function.name,
+            description: t.function.description ?? "",
+            input_schema: t.function.parameters ?? { type: "object", properties: {} },
+        }));
+    }
+    /**
+     * Convert messages to Anthropic format (separate system from conversation)
+     */
+    getAnthropicMessages() {
+        const msgs = [];
+        for (const msg of this.messages) {
+            if (msg.role === "system")
+                continue; // system handled separately
+            if (msg.role === "user") {
+                msgs.push({ role: "user", content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content) });
+            }
+            else if (msg.role === "assistant") {
+                const content = [];
+                if (msg.content) {
+                    content.push({ type: "text", text: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content) });
+                }
+                if ("tool_calls" in msg && Array.isArray(msg.tool_calls)) {
+                    for (const tc of msg.tool_calls) {
+                        let input = {};
+                        try {
+                            input = JSON.parse(tc.function.arguments);
+                        }
+                        catch { }
+                        content.push({
+                            type: "tool_use",
+                            id: tc.id,
+                            name: tc.function.name,
+                            input,
+                        });
+                    }
+                }
+                if (content.length > 0) {
+                    msgs.push({ role: "assistant", content });
+                }
+            }
+            else if (msg.role === "tool") {
+                const toolCallId = msg.tool_call_id;
+                const resultContent = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+                // Anthropic expects tool results as user messages with tool_result content
+                msgs.push({
+                    role: "user",
+                    content: [{
+                            type: "tool_result",
+                            tool_use_id: toolCallId,
+                            content: resultContent,
+                        }],
+                });
+            }
+        }
+        return msgs;
+    }
+    /**
+     * Anthropic-native streaming chat
+     */
+    async chatAnthropic(_userMessage) {
+        const client = this.anthropicClient;
+        let iterations = 0;
+        const MAX_ITERATIONS = 20;
+        while (iterations < MAX_ITERATIONS) {
+            iterations++;
+            const anthropicMessages = this.getAnthropicMessages();
+            const anthropicTools = this.getAnthropicTools();
+            const stream = client.messages.stream({
+                model: this.model,
+                max_tokens: this.maxTokens,
+                system: this.systemPrompt,
+                messages: anthropicMessages,
+                tools: anthropicTools,
+            });
+            let contentText = "";
+            const toolCalls = [];
+            let currentToolId = "";
+            let currentToolName = "";
+            let currentToolInput = "";
+            stream.on("text", (text) => {
+                contentText += text;
+                this.options.onToken?.(text);
+            });
+            const finalMessage = await stream.finalMessage();
+            // Track usage
+            if (finalMessage.usage) {
+                const promptTokens = finalMessage.usage.input_tokens;
+                const completionTokens = finalMessage.usage.output_tokens;
+                this.totalPromptTokens += promptTokens;
+                this.totalCompletionTokens += completionTokens;
+                const costs = getModelCost(this.model);
+                this.totalCost = (this.totalPromptTokens / 1_000_000) * costs.input +
+                    (this.totalCompletionTokens / 1_000_000) * costs.output;
+                updateSessionCost(this.sessionId, this.totalPromptTokens, this.totalCompletionTokens, this.totalCost);
+            }
+            // Extract tool uses from content blocks
+            for (const block of finalMessage.content) {
+                if (block.type === "tool_use") {
+                    toolCalls.push({
+                        id: block.id,
+                        name: block.name,
+                        input: block.input,
+                    });
+                }
+            }
+            // Build OpenAI-format assistant message for session storage
+            const assistantMessage = { role: "assistant", content: contentText || null };
+            if (toolCalls.length > 0) {
+                assistantMessage.tool_calls = toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: "function",
+                    function: { name: tc.name, arguments: JSON.stringify(tc.input) },
+                }));
+            }
+            this.messages.push(assistantMessage);
+            saveMessage(this.sessionId, assistantMessage);
+            // If no tool calls, we're done
+            if (toolCalls.length === 0) {
+                updateTokenEstimate(this.sessionId, this.estimateTokens());
+                return contentText || "(empty response)";
+            }
+            // Process tool calls
+            for (const toolCall of toolCalls) {
+                const args = toolCall.input;
+                this.options.onToolCall?.(toolCall.name, args);
+                // Check approval for dangerous tools
+                if (DANGEROUS_TOOLS.has(toolCall.name) && !this.autoApprove && !this.alwaysApproved.has(toolCall.name)) {
+                    if (this.options.onToolApproval) {
+                        let diff;
+                        if (toolCall.name === "write_file" && args.path && args.content) {
+                            const existing = getExistingContent(String(args.path), this.cwd);
+                            if (existing !== null) {
+                                diff = generateDiff(existing, String(args.content), String(args.path));
+                            }
+                        }
+                        const decision = await this.options.onToolApproval(toolCall.name, args, diff);
+                        if (decision === "no") {
+                            const denied = `Tool call "${toolCall.name}" was denied by the user.`;
+                            this.options.onToolResult?.(toolCall.name, denied);
+                            const deniedMsg = {
+                                role: "tool",
+                                tool_call_id: toolCall.id,
+                                content: denied,
+                            };
+                            this.messages.push(deniedMsg);
+                            saveMessage(this.sessionId, deniedMsg);
+                            continue;
+                        }
+                        if (decision === "always") {
+                            this.alwaysApproved.add(toolCall.name);
+                        }
+                    }
+                }
+                const result = await executeTool(toolCall.name, args, this.cwd);
+                this.options.onToolResult?.(toolCall.name, result);
+                // Auto-commit after successful write_file
+                if (this.gitEnabled && this.autoCommitEnabled && toolCall.name === "write_file" && result.startsWith("✅")) {
+                    const path = String(args.path ?? "unknown");
+                    const committed = autoCommit(this.cwd, path, "write");
+                    if (committed) {
+                        this.options.onGitCommit?.(`write ${path}`);
+                    }
+                }
+                const toolMsg = {
+                    role: "tool",
+                    tool_call_id: toolCall.id,
+                    content: result,
+                };
+                this.messages.push(toolMsg);
+                saveMessage(this.sessionId, toolMsg);
+            }
+        }
+        return "Max iterations reached. The agent may be stuck in a loop.";
+    }
     /**
      * Switch to a different model mid-session
      */
@@ -262,6 +534,86 @@ export class CodingAgent {
         }
         return Math.ceil(chars / 4);
     }
+    /**
+     * Check if context needs compression and compress if threshold exceeded
+     */
+    async maybeCompressContext() {
+        const currentTokens = this.estimateTokens();
+        if (currentTokens < this.compressionThreshold)
+            return;
+        // Keep: system prompt (index 0) + last 10 messages
+        const keepCount = 10;
+        if (this.messages.length <= keepCount + 1)
+            return; // Not enough to compress
+        const systemMsg = this.messages[0];
+        const middleMessages = this.messages.slice(1, this.messages.length - keepCount);
+        const recentMessages = this.messages.slice(this.messages.length - keepCount);
+        if (middleMessages.length === 0)
+            return;
+        // Build a summary of the middle messages
+        const summaryParts = [];
+        for (const msg of middleMessages) {
+            if (msg.role === "user" && typeof msg.content === "string") {
+                summaryParts.push(`User: ${msg.content.slice(0, 200)}`);
+            }
+            else if (msg.role === "assistant" && typeof msg.content === "string" && msg.content) {
+                summaryParts.push(`Assistant: ${msg.content.slice(0, 200)}`);
+            }
+            else if (msg.role === "tool") {
+                // Skip tool messages in summary to save tokens
+            }
+        }
+        // Use the active model to summarize
+        const summaryPrompt = `Summarize this conversation history in 2-3 concise paragraphs. Focus on: what was discussed, what files were modified, what decisions were made, and any important context for continuing the conversation.\n\n${summaryParts.join("\n")}`;
+        try {
+            let summary;
+            if (this.providerType === "anthropic" && this.anthropicClient) {
+                const response = await this.anthropicClient.messages.create({
+                    model: this.model,
+                    max_tokens: 500,
+                    messages: [{ role: "user", content: summaryPrompt }],
+                });
+                summary = response.content
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("");
+            }
+            else {
+                const response = await this.client.chat.completions.create({
+                    model: this.model,
+                    max_tokens: 500,
+                    messages: [{ role: "user", content: summaryPrompt }],
+                });
+                summary = response.choices[0]?.message?.content ?? "Previous conversation context.";
+            }
+            const compressedMsg = {
+                role: "assistant",
+                content: `[Context compressed: ${summary}]`,
+            };
+            const oldTokens = currentTokens;
+            this.messages = [systemMsg, compressedMsg, ...recentMessages];
+            const newTokens = this.estimateTokens();
+            this.options.onContextCompressed?.(oldTokens, newTokens);
+        }
+        catch {
+            // If summarization fails, just truncate without summary
+            const compressedMsg = {
+                role: "assistant",
+                content: "[Context compressed: Earlier conversation history was removed to stay within token limits.]",
+            };
+            const oldTokens = currentTokens;
+            this.messages = [systemMsg, compressedMsg, ...recentMessages];
+            const newTokens = this.estimateTokens();
+            this.options.onContextCompressed?.(oldTokens, newTokens);
+        }
+    }
+    getCostInfo() {
+        return {
+            promptTokens: this.totalPromptTokens,
+            completionTokens: this.totalCompletionTokens,
+            totalCost: this.totalCost,
+        };
+    }
     reset() {
         const systemMsg = this.messages[0];
         this.messages = [systemMsg];

package/dist/config.d.ts

@@ -2,6 +2,7 @@ export interface ProviderConfig {
     baseUrl: string;
     apiKey: string;
     model: string;
+    type?: "openai" | "anthropic";
 }
 export interface ProviderProfile extends ProviderConfig {
     name: string;
@@ -13,6 +14,7 @@ export interface CodemaxxingConfig {
         autoApprove: boolean;
         contextFiles: number;
         maxTokens: number;
+        contextCompressionThreshold?: number;
     };
 }
 export interface CLIArgs {
@@ -43,8 +45,4 @@ export declare function listModels(baseUrl: string, apiKey: string): Promise<str
  * Resolve provider configuration from auth store or config file
  * Priority: CLI args > auth store > config file > auto-detect
  */
-export declare function resolveProvider(providerId: string, cliArgs: CLIArgs): {
-    baseUrl: string;
-    apiKey: string;
-    model: string;
-} | null;
+export declare function resolveProvider(providerId: string, cliArgs: CLIArgs): ProviderConfig | null;

package/dist/config.js

@@ -102,6 +102,14 @@ export function applyOverrides(config, args) {
     if (args.provider && config.providers?.[args.provider]) {
         const profile = config.providers[args.provider];
         result.provider = { ...profile };
+        // Also check auth store for this provider
+        const authCred = getCredential(args.provider);
+        if (authCred) {
+            result.provider.baseUrl = authCred.baseUrl;
+            result.provider.apiKey = authCred.apiKey;
+        }
+        // Detect provider type
+        result.provider.type = detectProviderType(args.provider, result.provider.baseUrl);
     }
     // CLI flags override everything
     if (args.model)
@@ -110,6 +118,10 @@ export function applyOverrides(config, args) {
         result.provider.apiKey = args.apiKey;
     if (args.baseUrl)
         result.provider.baseUrl = args.baseUrl;
+    // Auto-detect type from baseUrl if not set
+    if (!result.provider.type && result.provider.baseUrl) {
+        result.provider.type = detectProviderType(args.provider || "", result.provider.baseUrl);
+    }
     return result;
 }
 export function getConfigPath() {
@@ -185,6 +197,7 @@ export function resolveProvider(providerId, cliArgs) {
             baseUrl: authCred.baseUrl,
             apiKey: authCred.apiKey,
             model: cliArgs.model || "auto",
+            type: detectProviderType(providerId, authCred.baseUrl),
         };
     }
     // Fall back to config file
@@ -195,7 +208,17 @@ export function resolveProvider(providerId, cliArgs) {
             baseUrl: provider.baseUrl,
             apiKey: cliArgs.apiKey || provider.apiKey,
             model: cliArgs.model || provider.model,
+            type: detectProviderType(providerId, provider.baseUrl),
         };
     }
     return null;
 }
+/**
+ * Detect provider type from ID or base URL
+ */
+function detectProviderType(providerId, baseUrl) {
+    if (providerId === "anthropic" || baseUrl.includes("anthropic.com")) {
+        return "anthropic";
+    }
+    return "openai";
+}