@agi-cli/server 0.1.105 → 0.1.107

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.105",
+	"version": "0.1.107",
 	"description": "HTTP API server for AGI CLI",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,8 +29,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@agi-cli/sdk": "0.1.105",
-		"@agi-cli/database": "0.1.105",
+		"@agi-cli/sdk": "0.1.107",
+		"@agi-cli/database": "0.1.107",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/runtime/compaction.ts

@@ -0,0 +1,254 @@
+/**
+ * Context compaction module for managing token usage.
+ *
+ * This module implements OpenCode-style context management:
+ * 1. Detects when context is overflowing (tokens > context_limit - output_limit)
+ * 2. Prunes old tool outputs by marking them as "compacted"
+ * 3. History builder returns "[Old tool result content cleared]" for compacted parts
+ *
+ * Pruning strategy:
+ * - Protect the last PRUNE_PROTECT tokens worth of tool calls (40,000)
+ * - Only prune if we'd save at least PRUNE_MINIMUM tokens (20,000)
+ * - Skip the last 2 turns to preserve recent context
+ * - Never prune "skill" or other protected tools
+ */
+
+import type { getDb } from '@agi-cli/database';
+import { messages, messageParts } from '@agi-cli/database/schema';
+import { eq, desc } from 'drizzle-orm';
+import { debugLog } from './debug.ts';
+
+// Token thresholds (matching OpenCode)
+export const PRUNE_MINIMUM = 20_000; // Only prune if we'd save at least this many tokens
+export const PRUNE_PROTECT = 40_000; // Protect last N tokens worth of tool calls
+
+// Tools that should never be pruned
+const PRUNE_PROTECTED_TOOLS = ['skill'];
+
+// Simple token estimation: ~4 chars per token
+export function estimateTokens(text: string): number {
+	return Math.max(0, Math.round((text || '').length / 4));
+}
+
+export interface TokenUsage {
+	input: number;
+	output: number;
+	cacheRead?: number;
+	cacheWrite?: number;
+	reasoning?: number;
+}
+
+export interface ModelLimits {
+	context: number;
+	output: number;
+}
+
+/**
+ * Check if context is overflowing based on token usage and model limits.
+ * Returns true if we've used more tokens than (context_limit - output_limit).
+ */
+export function isOverflow(tokens: TokenUsage, limits: ModelLimits): boolean {
+	if (limits.context === 0) return false;
+
+	const count = tokens.input + (tokens.cacheRead ?? 0) + tokens.output;
+	const usableContext = limits.context - limits.output;
+
+	const overflow = count > usableContext;
+	if (overflow) {
+		debugLog(
+			`[compaction] Context overflow detected: ${count} tokens used, ${usableContext} usable (${limits.context} context - ${limits.output} output)`,
+		);
+	}
+
+	return overflow;
+}
+
+/**
+ * Prune old tool outputs from a session to reduce context size.
+ *
+ * Goes backwards through tool results, protecting the last PRUNE_PROTECT tokens.
+ * Marks older tool results as "compacted" so history builder returns placeholder text.
+ */
+export async function pruneSession(
+	db: Awaited<ReturnType<typeof getDb>>,
+	sessionId: string,
+): Promise<{ pruned: number; saved: number }> {
+	debugLog(`[compaction] Starting prune for session ${sessionId}`);
+
+	// Get all messages in the session ordered by creation time
+	const allMessages = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.sessionId, sessionId))
+		.orderBy(desc(messages.createdAt));
+
+	let totalTokens = 0;
+	let prunedTokens = 0;
+	const toPrune: Array<{ id: string; content: string }> = [];
+	let turns = 0;
+
+	// Go backwards through messages
+	for (const msg of allMessages) {
+		// Count user messages as turns
+		if (msg.role === 'user') {
+			turns++;
+		}
+
+		// Skip the last 2 turns to preserve recent context
+		if (turns < 2) continue;
+
+		// Get all parts for this message
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, msg.id))
+			.orderBy(desc(messageParts.index));
+
+		for (const part of parts) {
+			// Only process tool results
+			if (part.type !== 'tool_result') continue;
+
+			// Skip protected tools
+			if (part.toolName && PRUNE_PROTECTED_TOOLS.includes(part.toolName)) {
+				continue;
+			}
+
+			// Parse content to check if already compacted
+			let content: { result?: unknown; compactedAt?: number };
+			try {
+				content = JSON.parse(part.content ?? '{}');
+			} catch {
+				continue;
+			}
+
+			// Stop if we hit already compacted content (we've pruned before)
+			if (content.compactedAt) {
+				debugLog(
+					`[compaction] Hit previously compacted content, stopping prune`,
+				);
+				break;
+			}
+
+			// Estimate tokens for this result
+			const estimate = estimateTokens(
+				typeof content.result === 'string'
+					? content.result
+					: JSON.stringify(content.result ?? ''),
+			);
+			totalTokens += estimate;
+
+			// If we've exceeded the protection threshold, mark for pruning
+			if (totalTokens > PRUNE_PROTECT) {
+				prunedTokens += estimate;
+				toPrune.push({ id: part.id, content: part.content ?? '{}' });
+			}
+		}
+	}
+
+	debugLog(
+		`[compaction] Found ${toPrune.length} tool results to prune, saving ~${prunedTokens} tokens`,
+	);
+
+	// Only prune if we'd save enough tokens to be worthwhile
+	if (prunedTokens > PRUNE_MINIMUM) {
+		const compactedAt = Date.now();
+
+		for (const part of toPrune) {
+			try {
+				const content = JSON.parse(part.content);
+				// Keep the structure but mark as compacted
+				content.compactedAt = compactedAt;
+				// Keep a small summary if it was a string result
+				if (typeof content.result === 'string' && content.result.length > 100) {
+					content.resultSummary = `${content.result.slice(0, 100)}...`;
+				}
+				// Clear the actual result to save space
+				content.result = null;
+
+				await db
+					.update(messageParts)
+					.set({ content: JSON.stringify(content) })
+					.where(eq(messageParts.id, part.id));
+			} catch (err) {
+				debugLog(
+					`[compaction] Failed to prune part ${part.id}: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		}
+
+		debugLog(
+			`[compaction] Pruned ${toPrune.length} tool results, saved ~${prunedTokens} tokens`,
+		);
+	} else {
+		debugLog(
+			`[compaction] Skipping prune, would only save ${prunedTokens} tokens (min: ${PRUNE_MINIMUM})`,
+		);
+	}
+
+	return { pruned: toPrune.length, saved: prunedTokens };
+}
+
+/**
+ * Get model limits from provider catalog or use defaults.
+ */
+export function getModelLimits(
+	provider: string,
+	model: string,
+): ModelLimits | null {
+	// Default limits for common models
+	// These should ideally come from the provider catalog
+	const defaults: Record<string, ModelLimits> = {
+		// Anthropic
+		'claude-sonnet-4-20250514': { context: 200000, output: 16000 },
+		'claude-3-5-sonnet-20241022': { context: 200000, output: 8192 },
+		'claude-3-5-haiku-20241022': { context: 200000, output: 8192 },
+		'claude-3-opus-20240229': { context: 200000, output: 4096 },
+		// OpenAI
+		'gpt-4o': { context: 128000, output: 16384 },
+		'gpt-4o-mini': { context: 128000, output: 16384 },
+		'gpt-4-turbo': { context: 128000, output: 4096 },
+		o1: { context: 200000, output: 100000 },
+		'o1-mini': { context: 128000, output: 65536 },
+		'o1-pro': { context: 200000, output: 100000 },
+		'o3-mini': { context: 200000, output: 100000 },
+		// Google
+		'gemini-2.0-flash': { context: 1000000, output: 8192 },
+		'gemini-1.5-pro': { context: 2000000, output: 8192 },
+		'gemini-1.5-flash': { context: 1000000, output: 8192 },
+	};
+
+	// Try exact match first
+	if (defaults[model]) {
+		return defaults[model];
+	}
+
+	// Try partial match (e.g., "claude-3-5-sonnet" matches "claude-3-5-sonnet-20241022")
+	for (const [key, limits] of Object.entries(defaults)) {
+		if (model.includes(key) || key.includes(model)) {
+			return limits;
+		}
+	}
+
+	// Return null if no match - caller should handle
+	debugLog(
+		`[compaction] No model limits found for ${provider}/${model}, skipping overflow check`,
+	);
+	return null;
+}
+
+/**
+ * Check if a tool result content is compacted.
+ */
+export function isCompacted(content: string): boolean {
+	try {
+		const parsed = JSON.parse(content);
+		return !!parsed.compactedAt;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Get the placeholder text for compacted tool results.
+ */
+export const COMPACTED_PLACEHOLDER = '[Old tool result content cleared]';

package/src/runtime/db-operations.ts

@@ -76,15 +76,14 @@ export async function updateSessionTokensIncremental(
 				: priorCachedMsg;
 
 	// Compute deltas for this step; clamp to 0 in case provider reports smaller values
-	// Cached tokens reduce the billable input, so we subtract them from the delta
 	const deltaInput = Math.max(0, cumPrompt - priorPromptMsg);
 	const deltaOutput = Math.max(0, cumCompletion - priorCompletionMsg);
 	const deltaCached = Math.max(0, cumCached - priorCachedMsg);
 	const deltaReasoning = Math.max(0, cumReasoning - priorReasoningMsg);
 
-	// Session input should only count non-cached tokens
-	// Total cached tokens are tracked separately for reference
-	const nextInputSess = priorInputSess + deltaInput - deltaCached;
+	// Note: AI SDK's inputTokens already excludes cached tokens for Anthropic,
+	// so we don't need to subtract deltaCached here. Just accumulate directly.
+	const nextInputSess = priorInputSess + deltaInput;
 	const nextOutputSess = priorOutputSess + deltaOutput;
 	const nextCachedSess = priorCachedSess + deltaCached;
 	const nextReasoningSess = priorReasoningSess + deltaReasoning;

package/src/runtime/history-builder.ts

@@ -4,6 +4,7 @@ import { messages, messageParts } from '@agi-cli/database/schema';
 import { eq, asc } from 'drizzle-orm';
 import { debugLog } from './debug.ts';
 import { ToolHistoryTracker } from './history/tool-history-tracker.ts';
+import { COMPACTED_PLACEHOLDER } from './compaction.ts';
 
 /**
  * Builds the conversation history for a session from the database,
@@ -93,12 +94,17 @@ export async function buildHistoryMessages(
 							name?: string;
 							callId?: string;
 							result?: unknown;
+							compactedAt?: number;
 						};
 						if (obj.callId) {
+							// If this tool result was compacted, return placeholder instead
+							const result = obj.compactedAt
+								? COMPACTED_PLACEHOLDER
+								: obj.result;
 							toolResults.push({
 								name: obj.name ?? 'tool',
 								callId: obj.callId,
-								result: obj.result,
+								result,
 							});
 						}
 					} catch {}

package/src/runtime/provider.ts

@@ -7,9 +7,13 @@ import {
 	setAuth,
 } from '@agi-cli/sdk';
 import { openai, createOpenAI } from '@ai-sdk/openai';
-import { anthropic, createAnthropic } from '@ai-sdk/anthropic';
+import { createAnthropic } from '@ai-sdk/anthropic';
 import { google, createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { toClaudeCodeName } from './tool-mapping.ts';
+
+// Version to report in user-agent for Claude Code compatibility
+const CLAUDE_CLI_VERSION = '1.0.61';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 
 export type ProviderName = ProviderId;
@@ -132,12 +136,181 @@ async function getAnthropicInstance(cfg: AGIConfig) {
 				}
 			}
 
+			// Required Claude Code headers
 			headers.authorization = `Bearer ${currentAuth.access}`;
 			headers['anthropic-beta'] =
-				'oauth-2025-04-20,claude-code-20250219,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14';
+				'claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14';
+			headers['anthropic-dangerous-direct-browser-access'] = 'true';
+			headers['anthropic-version'] = '2023-06-01';
+			headers['user-agent'] =
+				`claude-cli/${CLAUDE_CLI_VERSION} (external, cli)`;
+			headers['x-app'] = 'cli';
+			headers['content-type'] = 'application/json';
+			headers.accept = 'application/json';
+
+			// Stainless headers (fingerprinting)
+			headers['x-stainless-arch'] = process.arch === 'arm64' ? 'arm64' : 'x64';
+			headers['x-stainless-helper-method'] = 'stream';
+			headers['x-stainless-lang'] = 'js';
+			headers['x-stainless-os'] =
+				process.platform === 'darwin'
+					? 'MacOS'
+					: process.platform === 'win32'
+						? 'Windows'
+						: 'Linux';
+			headers['x-stainless-package-version'] = '0.70.0';
+			headers['x-stainless-retry-count'] = '0';
+			headers['x-stainless-runtime'] = 'node';
+			headers['x-stainless-runtime-version'] = process.version;
+			headers['x-stainless-timeout'] = '600';
+
+			// Add ?beta=true to URL
+			let url = typeof input === 'string' ? input : input.toString();
+			if (url.includes('/v1/messages') && !url.includes('beta=true')) {
+				url += url.includes('?') ? '&beta=true' : '?beta=true';
+			}
+
+			// Transform request body: tool names to PascalCase + apply caching
+			let body = init?.body;
+			if (body && typeof body === 'string') {
+				try {
+					const parsed = JSON.parse(body);
+
+					// Transform tool names
+					if (parsed.tools && Array.isArray(parsed.tools)) {
+						parsed.tools = parsed.tools.map(
+							(tool: { name: string; [key: string]: unknown }) => ({
+								...tool,
+								name: toClaudeCodeName(tool.name),
+							}),
+						);
+					}
+
+					// Apply ephemeral caching (max 4 cache breakpoints total)
+					// Adapter adds 2 tool cache blocks, so we can add 2 more:
+					// - 1 system block (the first one with tools description)
+					// - 1 message block (the last user message)
+					const MAX_SYSTEM_CACHE = 1;
+					const MAX_MESSAGE_CACHE = 1;
+					let systemCacheUsed = 0;
+					let messageCacheUsed = 0;
+
+					// Cache first system message only (contains agent instructions)
+					if (parsed.system && Array.isArray(parsed.system)) {
+						parsed.system = parsed.system.map(
+							(
+								block: { type: string; cache_control?: unknown },
+								index: number,
+							) => {
+								if (block.cache_control) return block;
+								if (
+									systemCacheUsed < MAX_SYSTEM_CACHE &&
+									index === 0 &&
+									block.type === 'text'
+								) {
+									systemCacheUsed++;
+									return { ...block, cache_control: { type: 'ephemeral' } };
+								}
+								return block;
+							},
+						);
+					}
+
+					// Transform tool names in messages and apply caching to last message only
+					if (parsed.messages && Array.isArray(parsed.messages)) {
+						const messageCount = parsed.messages.length;
+
+						parsed.messages = parsed.messages.map(
+							(
+								msg: {
+									role: string;
+									content: unknown;
+									[key: string]: unknown;
+								},
+								msgIndex: number,
+							) => {
+								// Only cache the very last message
+								const isLast = msgIndex === messageCount - 1;
+
+								if (Array.isArray(msg.content)) {
+									const content = msg.content.map(
+										(
+											block: {
+												type: string;
+												name?: string;
+												cache_control?: unknown;
+											},
+											blockIndex: number,
+										) => {
+											let transformedBlock = block;
+
+											// Transform tool names
+											if (block.type === 'tool_use' && block.name) {
+												transformedBlock = {
+													...block,
+													name: toClaudeCodeName(block.name),
+												};
+											}
+											if (block.type === 'tool_result' && block.name) {
+												transformedBlock = {
+													...block,
+													name: toClaudeCodeName(block.name),
+												};
+											}
+
+											// Add cache_control to last block of last message
+											if (
+												isLast &&
+												!transformedBlock.cache_control &&
+												messageCacheUsed < MAX_MESSAGE_CACHE &&
+												blockIndex === (msg.content as unknown[]).length - 1
+											) {
+												messageCacheUsed++;
+												return {
+													...transformedBlock,
+													cache_control: { type: 'ephemeral' },
+												};
+											}
+
+											return transformedBlock;
+										},
+									);
+									return { ...msg, content };
+								}
+
+								// For string content, wrap in array with cache_control if last message
+								if (
+									isLast &&
+									messageCacheUsed < MAX_MESSAGE_CACHE &&
+									typeof msg.content === 'string'
+								) {
+									messageCacheUsed++;
+									return {
+										...msg,
+										content: [
+											{
+												type: 'text',
+												text: msg.content,
+												cache_control: { type: 'ephemeral' },
+											},
+										],
+									};
+								}
+
+								return msg;
+							},
+						);
+					}
 
-			return fetch(input, {
+					body = JSON.stringify(parsed);
+				} catch {
+					// If parsing fails, send as-is
+				}
+			}
+
+			return fetch(url, {
 				...init,
+				body,
 				headers,
 			});
 		};
@@ -147,7 +320,116 @@ async function getAnthropicInstance(cfg: AGIConfig) {
 		});
 	}
 
-	return anthropic;
+	// For API key auth, also apply caching via customFetch
+	// This optimizes token usage even without OAuth
+	const customFetch = async (
+		input: string | URL | Request,
+		init?: RequestInit,
+	) => {
+		let body = init?.body;
+		if (body && typeof body === 'string') {
+			try {
+				const parsed = JSON.parse(body);
+
+				// Apply ephemeral caching (max 4 cache breakpoints total)
+				// Adapter adds 2 tool cache blocks, so we can add 2 more:
+				// - 1 system block + 1 message block = 2
+				const MAX_SYSTEM_CACHE = 1;
+				const MAX_MESSAGE_CACHE = 1;
+				let systemCacheUsed = 0;
+				let messageCacheUsed = 0;
+
+				// Cache first system message
+				if (parsed.system && Array.isArray(parsed.system)) {
+					parsed.system = parsed.system.map(
+						(
+							block: { type: string; cache_control?: unknown },
+							index: number,
+						) => {
+							if (block.cache_control) return block;
+							if (
+								systemCacheUsed < MAX_SYSTEM_CACHE &&
+								index === 0 &&
+								block.type === 'text'
+							) {
+								systemCacheUsed++;
+								return { ...block, cache_control: { type: 'ephemeral' } };
+							}
+							return block;
+						},
+					);
+				}
+
+				// Cache last message only
+				if (parsed.messages && Array.isArray(parsed.messages)) {
+					const messageCount = parsed.messages.length;
+					parsed.messages = parsed.messages.map(
+						(
+							msg: {
+								role: string;
+								content: unknown;
+								[key: string]: unknown;
+							},
+							msgIndex: number,
+						) => {
+							const isLast = msgIndex === messageCount - 1;
+
+							if (Array.isArray(msg.content)) {
+								const blocks = msg.content as {
+									type: string;
+									cache_control?: unknown;
+								}[];
+								const content = blocks.map((block, blockIndex) => {
+									if (block.cache_control) return block;
+									if (
+										isLast &&
+										messageCacheUsed < MAX_MESSAGE_CACHE &&
+										blockIndex === blocks.length - 1
+									) {
+										messageCacheUsed++;
+										return { ...block, cache_control: { type: 'ephemeral' } };
+									}
+									return block;
+								});
+								return { ...msg, content };
+							}
+
+							if (
+								isLast &&
+								messageCacheUsed < MAX_MESSAGE_CACHE &&
+								typeof msg.content === 'string'
+							) {
+								messageCacheUsed++;
+								return {
+									...msg,
+									content: [
+										{
+											type: 'text',
+											text: msg.content,
+											cache_control: { type: 'ephemeral' },
+										},
+									],
+								};
+							}
+
+							return msg;
+						},
+					);
+				}
+
+				body = JSON.stringify(parsed);
+			} catch {
+				// If parsing fails, send as-is
+			}
+		}
+
+		const url = typeof input === 'string' ? input : input.toString();
+		return fetch(url, { ...init, body });
+	};
+
+	return createAnthropic({
+		fetch: customFetch as typeof fetch,
+	});
 }
 
 export async function resolveModel(

package/src/runtime/runner.ts

@@ -1,5 +1,5 @@
 import { hasToolCall, streamText } from 'ai';
-import { loadConfig } from '@agi-cli/sdk';
+import { loadConfig, getAuth } from '@agi-cli/sdk';
 import { getDb } from '@agi-cli/database';
 import { messageParts } from '@agi-cli/database/schema';
 import { eq } from 'drizzle-orm';
@@ -223,7 +223,11 @@ async function runAssistant(opts: RunOpts) {
 		opts,
 		db,
 	);
-	const toolset = adaptTools(gated, sharedCtx, opts.provider);
+
+	// Get auth type for Claude Code OAuth detection
+	const providerAuth = await getAuth(opts.provider, opts.projectRoot);
+	const authType = providerAuth?.type;
+	const toolset = adaptTools(gated, sharedCtx, opts.provider, authType);
 
 	let _finishObserved = false;
 	const unsubscribeFinish = subscribe(opts.sessionId, (evt) => {

package/src/runtime/stream-handlers.ts

@@ -8,6 +8,13 @@ import { toErrorPayload } from './error-handling.ts';
 import type { RunOpts } from './session-queue.ts';
 import type { ToolAdapterContext } from '../tools/adapter.ts';
 import type { ProviderMetadata, UsageData } from './db-operations.ts';
+import {
+	pruneSession,
+	isOverflow,
+	getModelLimits,
+	type TokenUsage,
+} from './compaction.ts';
+import { debugLog } from './debug.ts';
 
 type StepFinishEvent = {
 	usage?: UsageData;
@@ -277,6 +284,7 @@ export function createFinishHandler(
 					inputTokens: Number(sessRows[0].promptTokens ?? 0),
 					outputTokens: Number(sessRows[0].completionTokens ?? 0),
 					totalTokens: Number(sessRows[0].totalTokens ?? 0),
+					cachedInputTokens: Number(sessRows[0].cachedInputTokens ?? 0),
 				}
 			: fin.usage;
 
@@ -284,6 +292,37 @@ export function createFinishHandler(
 			? estimateModelCostUsd(opts.provider, opts.model, usage)
 			: undefined;
 
+		// Check for context overflow and prune if needed
+		if (usage) {
+			try {
+				const limits = getModelLimits(opts.provider, opts.model);
+				if (limits) {
+					const tokenUsage: TokenUsage = {
+						input: usage.inputTokens ?? 0,
+						output: usage.outputTokens ?? 0,
+						cacheRead:
+							(usage as { cachedInputTokens?: number }).cachedInputTokens ?? 0,
+					};
+
+					if (isOverflow(tokenUsage, limits)) {
+						debugLog(
+							`[stream-handlers] Context overflow detected, triggering prune for session ${opts.sessionId}`,
+						);
+						// Prune asynchronously - don't block the finish handler
+						pruneSession(db, opts.sessionId).catch((err) => {
+							debugLog(
+								`[stream-handlers] Prune failed: ${err instanceof Error ? err.message : String(err)}`,
+							);
+						});
+					}
+				}
+			} catch (err) {
+				debugLog(
+					`[stream-handlers] Overflow check failed: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		}
+
 		publish({
 			type: 'message.completed',
 			sessionId: opts.sessionId,

package/src/runtime/tool-mapping.ts

@@ -0,0 +1,156 @@
+/**
+ * Tool name mapping for Claude Code OAuth compatibility.
+ *
+ * Claude Code OAuth requires PascalCase tool names but does NOT whitelist
+ * specific tools. Any tool with a PascalCase name is accepted.
+ *
+ * This module provides bidirectional mapping between AGI's canonical
+ * snake_case names and the PascalCase format required for OAuth.
+ */
+
+export type ToolNamingConvention = 'canonical' | 'claude-code';
+
+/**
+ * Mapping from AGI canonical names to PascalCase names.
+ * Includes ALL AGI tools for complete OAuth compatibility.
+ */
+export const CANONICAL_TO_PASCAL: Record<string, string> = {
+	// File system operations
+	read: 'Read',
+	write: 'Write',
+	edit: 'Edit',
+	ls: 'Ls',
+	tree: 'Tree',
+	cd: 'Cd',
+	pwd: 'Pwd',
+
+	// Search operations
+	glob: 'Glob',
+	ripgrep: 'Grep', // Maps to Grep for Claude Code compatibility
+	grep: 'Grep',
+
+	// Execution
+	bash: 'Bash',
+	terminal: 'Terminal',
+
+	// Git operations
+	git_status: 'GitStatus',
+	git_diff: 'GitDiff',
+	git_commit: 'GitCommit',
+
+	// Patch/edit
+	apply_patch: 'ApplyPatch',
+
+	// Task management
+	update_plan: 'UpdatePlan',
+	progress_update: 'ProgressUpdate',
+	finish: 'Finish',
+
+	// Web operations
+	websearch: 'WebSearch',
+};
+
+/**
+ * Reverse mapping from PascalCase names to canonical.
+ * Built to handle the many-to-one ripgrep/grep → Grep mapping.
+ */
+export const PASCAL_TO_CANONICAL: Record<string, string> = {
+	// File system operations
+	Read: 'read',
+	Write: 'write',
+	Edit: 'edit',
+	Ls: 'ls',
+	Tree: 'tree',
+	Cd: 'cd',
+	Pwd: 'pwd',
+
+	// Search operations
+	Glob: 'glob',
+	Grep: 'ripgrep', // Maps back to ripgrep (primary search tool)
+
+	// Execution
+	Bash: 'bash',
+	Terminal: 'terminal',
+
+	// Git operations
+	GitStatus: 'git_status',
+	GitDiff: 'git_diff',
+	GitCommit: 'git_commit',
+
+	// Patch/edit
+	ApplyPatch: 'apply_patch',
+
+	// Task management
+	UpdatePlan: 'update_plan',
+	ProgressUpdate: 'progress_update',
+	Finish: 'finish',
+
+	// Web operations
+	WebSearch: 'websearch',
+};
+
+/**
+ * Convert a canonical tool name to PascalCase format.
+ */
+export function toClaudeCodeName(canonical: string): string {
+	if (CANONICAL_TO_PASCAL[canonical]) {
+		return CANONICAL_TO_PASCAL[canonical];
+	}
+	// Default: convert snake_case to PascalCase
+	return canonical
+		.split('_')
+		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+		.join('');
+}
+
+/**
+ * Convert a PascalCase tool name to canonical format.
+ */
+export function toCanonicalName(pascalCase: string): string {
+	if (PASCAL_TO_CANONICAL[pascalCase]) {
+		return PASCAL_TO_CANONICAL[pascalCase];
+	}
+	// Default: convert PascalCase to snake_case
+	return pascalCase
+		.replace(/([A-Z])/g, '_$1')
+		.toLowerCase()
+		.replace(/^_/, '');
+}
+
+/**
+ * Check if the current provider/auth combo requires PascalCase naming.
+ */
+export function requiresClaudeCodeNaming(
+	provider: string,
+	authType?: string,
+): boolean {
+	return provider === 'anthropic' && authType === 'oauth';
+}
+
+/**
+ * Transform a tool definition for Claude Code OAuth.
+ * Returns a new object with the transformed name.
+ */
+export function transformToolForClaudeCode<T extends { name: string }>(
+	tool: T,
+): T {
+	return {
+		...tool,
+		name: toClaudeCodeName(tool.name),
+	};
+}
+
+/**
+ * Transform tool call arguments to canonical names.
+ * Used when receiving tool calls from Claude Code OAuth.
+ */
+export function normalizeToolCall<T extends { name: string }>(
+	call: T,
+	fromClaudeCode: boolean,
+): T {
+	if (!fromClaudeCode) return call;
+	return {
+		...call,
+		name: toCanonicalName(call.name),
+	};
+}

package/src/tools/adapter.ts

@@ -9,6 +9,10 @@ import type {
 	StepExecutionState,
 } from '../runtime/tool-context.ts';
 import { isToolError } from '@agi-cli/sdk/tools/error';
+import {
+	toClaudeCodeName,
+	requiresClaudeCodeNaming,
+} from '../runtime/tool-mapping.ts';
 
 export type { ToolAdapterContext } from '../runtime/tool-context.ts';
 
@@ -47,6 +51,7 @@ export function adaptTools(
 	tools: DiscoveredTool[],
 	ctx: ToolAdapterContext,
 	provider?: string,
+	authType?: string,
 ) {
 	const out: Record<string, Tool> = {};
 	const pendingCalls = new Map<string, PendingCallMeta[]>();
@@ -56,6 +61,12 @@ export function adaptTools(
 	};
 	let firstToolCallReported = false;
 
+	// Determine if we need Claude Code naming (PascalCase)
+	const useClaudeCodeNaming = requiresClaudeCodeNaming(
+		provider ?? '',
+		authType,
+	);
+
 	if (!ctx.stepExecution) {
 		ctx.stepExecution = { states: new Map<number, StepExecutionState>() };
 	}
@@ -66,8 +77,14 @@ export function adaptTools(
 	const cacheableTools = new Set(['read', 'write', 'bash', 'edit']);
 	let cachedToolCount = 0;
 
-	for (const { name, tool } of tools) {
+	for (const { name: canonicalName, tool } of tools) {
 		const base = tool;
+		// Use PascalCase for Claude Code OAuth, otherwise canonical (snake_case)
+		const registrationName = useClaudeCodeNaming
+			? toClaudeCodeName(canonicalName)
+			: canonicalName;
+		// Always use canonical name for DB storage and events
+		const name = canonicalName;
 
 		const processedToolErrors = new WeakSet<object>();
 
@@ -145,7 +162,7 @@ export function adaptTools(
 			? { anthropic: { cacheControl: { type: 'ephemeral' as const } } }
 			: undefined;
 
-		out[name] = {
+		out[registrationName] = {
 			...base,
 			...(providerOptions ? { providerOptions } : {}),
 			async onInputStart(options: unknown) {