@ottocode/server 0.1.173

package/src/tools/adapter.ts

@@ -0,0 +1,634 @@
+import type { Tool } from 'ai';
+import { messageParts, sessions } from '@ottocode/database/schema';
+import { eq } from 'drizzle-orm';
+import { publish } from '../events/bus.ts';
+import type { DiscoveredTool } from '@ottocode/sdk';
+import { getCwd, setCwd, joinRelative } from '../runtime/utils/cwd.ts';
+import type {
+	ToolAdapterContext,
+	StepExecutionState,
+} from '../runtime/tools/context.ts';
+import { isToolError } from '@ottocode/sdk/tools/error';
+import {
+	toClaudeCodeName,
+	requiresClaudeCodeNaming,
+} from '../runtime/tools/mapping.ts';
+import {
+	requiresApproval,
+	requestApproval,
+} from '../runtime/tools/approval.ts';
+
+export type { ToolAdapterContext } from '../runtime/tools/context.ts';
+
+type ToolExecuteSignature = Tool['execute'] extends (
+	input: infer Input,
+	options: infer Options,
+) => infer Result
+	? { input: Input; options: Options; result: Result }
+	: { input: unknown; options: unknown; result: unknown };
+type ToolExecuteInput = ToolExecuteSignature['input'];
+type ToolExecuteOptions = ToolExecuteSignature['options'] extends never
+	? undefined
+	: ToolExecuteSignature['options'];
+type ToolExecuteReturn = ToolExecuteSignature['result'];
+
+type PendingCallMeta = {
+	callId: string;
+	startTs: number;
+	stepIndex?: number;
+	args?: unknown;
+	approvalPromise?: Promise<boolean>;
+};
+
+function getPendingQueue(
+	map: Map<string, PendingCallMeta[]>,
+	name: string,
+): PendingCallMeta[] {
+	let queue = map.get(name);
+	if (!queue) {
+		queue = [];
+		map.set(name, queue);
+	}
+	return queue;
+}
+
+export function adaptTools(
+	tools: DiscoveredTool[],
+	ctx: ToolAdapterContext,
+	provider?: string,
+	authType?: string,
+) {
+	const out: Record<string, Tool> = {};
+	const pendingCalls = new Map<string, PendingCallMeta[]>();
+	const failureState: { active: boolean; toolName?: string } = {
+		active: false,
+		toolName: undefined,
+	};
+	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>() };
+	}
+	const stepStates = ctx.stepExecution.states;
+
+	// Anthropic allows max 4 cache_control blocks
+	// Cache only the most frequently used tools: read, write, bash
+	const cacheableTools = new Set(['read', 'write', 'bash', 'edit']);
+	let cachedToolCount = 0;
+
+	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>();
+
+		const persistToolErrorResult = async (
+			errorResult: unknown,
+			{
+				callId,
+				startTs,
+				stepIndexForEvent,
+				args,
+			}: {
+				callId?: string;
+				startTs?: number;
+				stepIndexForEvent: number;
+				args?: unknown;
+			},
+		) => {
+			const resultPartId = crypto.randomUUID();
+			const endTs = Date.now();
+			const dur =
+				typeof startTs === 'number' ? Math.max(0, endTs - startTs) : null;
+
+			const contentObj: {
+				name: string;
+				result: unknown;
+				callId?: string;
+				args?: unknown;
+			} = {
+				name,
+				result: errorResult,
+				callId,
+			};
+
+			if (args !== undefined) {
+				contentObj.args = args;
+			}
+
+			const index = await ctx.nextIndex();
+
+			await ctx.db.insert(messageParts).values({
+				id: resultPartId,
+				messageId: ctx.messageId,
+				index,
+				stepIndex: stepIndexForEvent,
+				type: 'tool_result',
+				content: JSON.stringify(contentObj),
+				agent: ctx.agent,
+				provider: ctx.provider,
+				model: ctx.model,
+				startedAt: startTs,
+				completedAt: endTs,
+				toolName: name,
+				toolCallId: callId,
+				toolDurationMs: dur ?? undefined,
+			});
+
+			publish({
+				type: 'tool.result',
+				sessionId: ctx.sessionId,
+				payload: { ...contentObj, stepIndex: stepIndexForEvent },
+			});
+		};
+
+		// Add cache control for Anthropic to cache tool definitions (max 2 tools)
+		const shouldCache =
+			provider === 'anthropic' &&
+			cacheableTools.has(name) &&
+			cachedToolCount < 2;
+
+		if (shouldCache) {
+			cachedToolCount++;
+		}
+
+		const providerOptions = shouldCache
+			? { anthropic: { cacheControl: { type: 'ephemeral' as const } } }
+			: undefined;
+
+		out[registrationName] = {
+			...base,
+			...(providerOptions ? { providerOptions } : {}),
+			async onInputStart(options: unknown) {
+				const queue = getPendingQueue(pendingCalls, name);
+				queue.push({
+					callId: crypto.randomUUID(),
+					startTs: Date.now(),
+					stepIndex: ctx.stepIndex,
+				});
+				if (typeof base.onInputStart === 'function')
+					// biome-ignore lint/suspicious/noExplicitAny: AI SDK types are complex
+					await base.onInputStart(options as any);
+			},
+			async onInputDelta(options: unknown) {
+				const delta = (options as { inputTextDelta?: string } | undefined)
+					?.inputTextDelta;
+				const queue = pendingCalls.get(name);
+				const meta = queue?.length ? queue[queue.length - 1] : undefined;
+				// Stream tool argument deltas as events if needed
+				publish({
+					type: 'tool.delta',
+					sessionId: ctx.sessionId,
+					payload: {
+						name,
+						channel: 'input',
+						delta,
+						stepIndex: meta?.stepIndex ?? ctx.stepIndex,
+						callId: meta?.callId,
+						messageId: ctx.messageId,
+					},
+				});
+				if (typeof base.onInputDelta === 'function')
+					// biome-ignore lint/suspicious/noExplicitAny: AI SDK types are complex
+					await base.onInputDelta(options as any);
+			},
+			async onInputAvailable(options: unknown) {
+				const args = (options as { input?: unknown } | undefined)?.input;
+				const queue = getPendingQueue(pendingCalls, name);
+				let meta = queue.length ? queue[queue.length - 1] : undefined;
+				if (!meta) {
+					meta = {
+						callId: crypto.randomUUID(),
+						startTs: Date.now(),
+						stepIndex: ctx.stepIndex,
+					};
+					queue.push(meta);
+				}
+				meta.stepIndex = ctx.stepIndex;
+				meta.args = args;
+				const callId = meta.callId;
+				const callPartId = crypto.randomUUID();
+				const startTs = meta.startTs;
+
+				if (
+					!firstToolCallReported &&
+					typeof ctx.onFirstToolCall === 'function'
+				) {
+					firstToolCallReported = true;
+					try {
+						ctx.onFirstToolCall();
+					} catch {}
+				}
+
+				// Special-case: progress updates must render instantly. Publish before any DB work.
+				if (name === 'progress_update') {
+					publish({
+						type: 'tool.call',
+						sessionId: ctx.sessionId,
+						payload: {
+							name,
+							args,
+							callId,
+							stepIndex: ctx.stepIndex,
+							messageId: ctx.messageId,
+						},
+					});
+					// Persist synchronously to maintain correct ordering
+					try {
+						const index = await ctx.nextIndex();
+						await ctx.db.insert(messageParts).values({
+							id: callPartId,
+							messageId: ctx.messageId,
+							index,
+							stepIndex: ctx.stepIndex,
+							type: 'tool_call',
+							content: JSON.stringify({ name, args, callId }),
+							agent: ctx.agent,
+							provider: ctx.provider,
+							model: ctx.model,
+							startedAt: startTs,
+							toolName: name,
+							toolCallId: callId,
+						});
+					} catch {}
+					if (typeof base.onInputAvailable === 'function') {
+						// biome-ignore lint/suspicious/noExplicitAny: AI SDK types are complex
+						await base.onInputAvailable(options as any);
+					}
+					return;
+				}
+
+				// Publish promptly so UI shows the call header before results
+				publish({
+					type: 'tool.call',
+					sessionId: ctx.sessionId,
+					payload: {
+						name,
+						args,
+						callId,
+						stepIndex: ctx.stepIndex,
+						messageId: ctx.messageId,
+					},
+				});
+				// Persist synchronously to maintain correct ordering
+				try {
+					const index = await ctx.nextIndex();
+					await ctx.db.insert(messageParts).values({
+						id: callPartId,
+						messageId: ctx.messageId,
+						index,
+						stepIndex: ctx.stepIndex,
+						type: 'tool_call',
+						content: JSON.stringify({ name, args, callId }),
+						agent: ctx.agent,
+						provider: ctx.provider,
+						model: ctx.model,
+						startedAt: startTs,
+						toolName: name,
+						toolCallId: callId,
+					});
+				} catch {}
+				// Start approval request with full args
+				if (
+					ctx.toolApprovalMode &&
+					requiresApproval(name, ctx.toolApprovalMode)
+				) {
+					meta.approvalPromise = requestApproval(
+						ctx.sessionId,
+						ctx.messageId,
+						callId,
+						name,
+						args,
+					);
+				}
+				if (typeof base.onInputAvailable === 'function') {
+					// biome-ignore lint/suspicious/noExplicitAny: AI SDK types are complex
+					await base.onInputAvailable(options as any);
+				}
+			},
+			async execute(input: ToolExecuteInput, options: ToolExecuteOptions) {
+				const queue = pendingCalls.get(name);
+				const meta = queue?.shift();
+				if (queue && queue.length === 0) pendingCalls.delete(name);
+				const callIdFromQueue = meta?.callId;
+				const startTsFromQueue = meta?.startTs;
+				const stepIndexForEvent = meta?.stepIndex ?? ctx.stepIndex;
+
+				const stepKey =
+					typeof stepIndexForEvent === 'number' &&
+					Number.isFinite(stepIndexForEvent)
+						? stepIndexForEvent
+						: 0;
+				let stepState = stepStates.get(stepKey);
+				if (!stepState) {
+					stepState = {
+						chain: Promise.resolve(),
+						failed: false,
+						failedToolName: undefined,
+					};
+					stepStates.set(stepKey, stepState);
+				}
+
+				const executeWithGuards = async (): Promise<ToolExecuteReturn> => {
+					try {
+						// Await approval if it was requested in onInputAvailable
+						if (meta?.approvalPromise) {
+							const approved = await meta.approvalPromise;
+							if (!approved) {
+								return {
+									ok: false,
+									error: 'Tool execution rejected by user',
+								} as ToolExecuteReturn;
+							}
+						}
+						// Handle session-relative paths and cwd tools
+						let res: ToolExecuteReturn | { cwd: string } | null | undefined;
+						const cwd = getCwd(ctx.sessionId);
+						if (name === 'pwd') {
+							res = { cwd };
+						} else if (name === 'cd') {
+							const next = joinRelative(
+								cwd,
+								String((input as Record<string, unknown>)?.path ?? '.'),
+							);
+							setCwd(ctx.sessionId, next);
+							res = { cwd: next };
+						} else if (
+							['read', 'write', 'ls', 'tree'].includes(name) &&
+							typeof (input as Record<string, unknown>)?.path === 'string'
+						) {
+							const rel = joinRelative(
+								cwd,
+								String((input as Record<string, unknown>).path),
+							);
+							const nextInput = {
+								...(input as Record<string, unknown>),
+								path: rel,
+							} as ToolExecuteInput;
+							// biome-ignore lint/suspicious/noExplicitAny: AI SDK types are complex
+							res = base.execute?.(nextInput, options as any);
+						} else if (name === 'bash') {
+							const needsCwd =
+								!input ||
+								typeof (input as Record<string, unknown>).cwd !== 'string';
+							const nextInput = needsCwd
+								? ({
+										...(input as Record<string, unknown>),
+										cwd,
+									} as ToolExecuteInput)
+								: input;
+							// biome-ignore lint/suspicious/noExplicitAny: AI SDK types are complex
+							res = base.execute?.(nextInput, options as any);
+						} else {
+							// biome-ignore lint/suspicious/noExplicitAny: AI SDK types are complex
+							res = base.execute?.(input, options as any);
+						}
+						let result: unknown = res;
+						// If tool returns an async iterable, stream deltas while accumulating
+						if (res && typeof res === 'object' && Symbol.asyncIterator in res) {
+							const chunks: unknown[] = [];
+							for await (const chunk of res as AsyncIterable<unknown>) {
+								chunks.push(chunk);
+								publish({
+									type: 'tool.delta',
+									sessionId: ctx.sessionId,
+									payload: {
+										name,
+										channel: 'output',
+										delta: chunk,
+										stepIndex: stepIndexForEvent,
+										callId: callIdFromQueue,
+										messageId: ctx.messageId,
+									},
+								});
+							}
+							// Prefer the last chunk as the result if present, otherwise the entire array
+							result = chunks.length > 0 ? chunks[chunks.length - 1] : null;
+						} else {
+							// Await promise or passthrough value
+							result = await Promise.resolve(res as ToolExecuteReturn);
+						}
+
+						if (isToolError(result)) {
+							stepState.failed = true;
+							stepState.failedToolName = name;
+							failureState.active = true;
+							failureState.toolName = name;
+
+							await persistToolErrorResult(result, {
+								callId: callIdFromQueue,
+								startTs: startTsFromQueue,
+								stepIndexForEvent,
+								args: meta?.args,
+							});
+							processedToolErrors.add(result as object);
+							return result as ToolExecuteReturn;
+						}
+
+						const resultPartId = crypto.randomUUID();
+						const callId = callIdFromQueue;
+						const startTs = startTsFromQueue;
+						const contentObj: {
+							name: string;
+							result: unknown;
+							callId?: string;
+							artifact?: unknown;
+							args?: unknown;
+						} = {
+							name,
+							result,
+							callId,
+						};
+						if (meta?.args !== undefined) {
+							contentObj.args = meta.args;
+						}
+						if (result && typeof result === 'object' && 'artifact' in result) {
+							try {
+								const maybeArtifact = (result as { artifact?: unknown })
+									.artifact;
+								if (maybeArtifact !== undefined)
+									contentObj.artifact = maybeArtifact;
+							} catch {}
+						}
+
+						const index = await ctx.nextIndex();
+						const endTs = Date.now();
+						const dur =
+							typeof startTs === 'number' ? Math.max(0, endTs - startTs) : null;
+
+						// Special-case: keep progress_update result lightweight; publish first, persist best-effort
+						if (name === 'progress_update') {
+							stepState.failed = false;
+							stepState.failedToolName = undefined;
+							if (failureState.active && failureState.toolName === name) {
+								failureState.active = false;
+								failureState.toolName = undefined;
+							}
+							publish({
+								type: 'tool.result',
+								sessionId: ctx.sessionId,
+								payload: { ...contentObj, stepIndex: stepIndexForEvent },
+							});
+							// Persist without blocking the event loop
+							(async () => {
+								try {
+									await ctx.db.insert(messageParts).values({
+										id: resultPartId,
+										messageId: ctx.messageId,
+										index,
+										stepIndex: stepIndexForEvent,
+										type: 'tool_result',
+										content: JSON.stringify(contentObj),
+										agent: ctx.agent,
+										provider: ctx.provider,
+										model: ctx.model,
+										startedAt: startTs,
+										completedAt: endTs,
+										toolName: name,
+										toolCallId: callId,
+										toolDurationMs: dur ?? undefined,
+									});
+								} catch {}
+							})();
+							return result as ToolExecuteReturn;
+						}
+
+						stepState.failed = false;
+						stepState.failedToolName = undefined;
+						if (failureState.active && failureState.toolName === name) {
+							failureState.active = false;
+							failureState.toolName = undefined;
+						}
+
+						await ctx.db.insert(messageParts).values({
+							id: resultPartId,
+							messageId: ctx.messageId,
+							index,
+							stepIndex: stepIndexForEvent,
+							type: 'tool_result',
+							content: JSON.stringify(contentObj),
+							agent: ctx.agent,
+							provider: ctx.provider,
+							model: ctx.model,
+							startedAt: startTs,
+							completedAt: endTs,
+							toolName: name,
+							toolCallId: callId,
+							toolDurationMs: dur ?? undefined,
+						});
+						// Update session aggregates: total tool time and counts per tool
+						try {
+							const sessRows = await ctx.db
+								.select()
+								.from(sessions)
+								.where(eq(sessions.id, ctx.sessionId));
+							if (sessRows.length) {
+								const row = sessRows[0] as typeof sessions.$inferSelect;
+								const totalToolTimeMs =
+									Number(row.totalToolTimeMs || 0) + (dur ?? 0);
+								let counts: Record<string, number> = {};
+								try {
+									counts = row.toolCountsJson
+										? JSON.parse(row.toolCountsJson)
+										: {};
+								} catch {}
+								counts[name] = (counts[name] || 0) + 1;
+								await ctx.db
+									.update(sessions)
+									.set({
+										totalToolTimeMs,
+										toolCountsJson: JSON.stringify(counts),
+										lastActiveAt: endTs,
+									})
+									.where(eq(sessions.id, ctx.sessionId));
+							}
+						} catch {}
+						publish({
+							type: 'tool.result',
+							sessionId: ctx.sessionId,
+							payload: { ...contentObj, stepIndex: stepIndexForEvent },
+						});
+						if (name === 'update_todos') {
+							try {
+								const resultValue = (contentObj as { result?: unknown })
+									.result as { items?: unknown; note?: unknown } | undefined;
+								if (resultValue && Array.isArray(resultValue.items)) {
+									publish({
+										type: 'plan.updated',
+										sessionId: ctx.sessionId,
+										payload: {
+											items: resultValue.items,
+											note: resultValue.note,
+										},
+									});
+								}
+							} catch {}
+						}
+						return result as ToolExecuteReturn;
+					} catch (error) {
+						stepState.failed = true;
+						stepState.failedToolName = name;
+						failureState.active = true;
+						failureState.toolName = name;
+
+						// Tool execution failed
+						if (
+							isToolError(error) &&
+							processedToolErrors.has(error as object)
+						) {
+							throw error;
+						}
+
+						const errorResult = isToolError(error)
+							? error
+							: (() => {
+									const errorMessage =
+										error instanceof Error ? error.message : String(error);
+									const errorStack =
+										error instanceof Error ? error.stack : undefined;
+									return {
+										ok: false,
+										error: errorMessage,
+										stack: errorStack,
+									};
+								})();
+
+						await persistToolErrorResult(errorResult, {
+							callId: callIdFromQueue,
+							startTs: startTsFromQueue,
+							stepIndexForEvent,
+							args: meta?.args,
+						});
+
+						if (isToolError(error)) {
+							processedToolErrors.add(error as object);
+						}
+
+						return errorResult as ToolExecuteReturn;
+					}
+				};
+
+				const queued = stepState.chain
+					.catch(() => undefined)
+					.then(() => executeWithGuards());
+				stepState.chain = queued.then(
+					() => undefined,
+					() => undefined,
+				);
+				return queued;
+			},
+		} as Tool;
+	}
+	return out;
+}