@agi-cli/server 0.1.93 → 0.1.95

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.93",
+	"version": "0.1.95",
 	"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.93",
-		"@agi-cli/database": "0.1.93",
+		"@agi-cli/sdk": "0.1.95",
+		"@agi-cli/database": "0.1.95",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/index.ts

@@ -251,4 +251,4 @@ export {
 	setTraceEnabled,
 	isTraceEnabled,
 } from './runtime/debug-state.ts';
-export { logger } from './runtime/logger.ts';
+export { logger } from '@agi-cli/sdk';

package/src/routes/ask.ts

@@ -7,7 +7,7 @@ import type {
 import { handleAskRequest } from '../runtime/ask-service.ts';
 import type { EmbeddedAppConfig } from '../index.ts';
 import { serializeError } from '../runtime/api-error.ts';
-import { logger } from '../runtime/logger.ts';
+import { logger } from '@agi-cli/sdk';
 
 export function registerAskRoutes(app: Hono) {
 	app.post('/v1/ask', async (c) => {

package/src/routes/config/agents.ts

@@ -1,7 +1,7 @@
 import type { Hono } from 'hono';
 import { loadConfig } from '@agi-cli/sdk';
 import type { EmbeddedAppConfig } from '../../index.ts';
-import { logger } from '../../runtime/logger.ts';
+import { logger } from '@agi-cli/sdk';
 import { serializeError } from '../../runtime/api-error.ts';
 import { discoverAllAgents, getDefault } from './utils.ts';
 

package/src/routes/config/cwd.ts

@@ -1,6 +1,6 @@
 import type { Hono } from 'hono';
 import { basename } from 'node:path';
-import { logger } from '../../runtime/logger.ts';
+import { logger } from '@agi-cli/sdk';
 import { serializeError } from '../../runtime/api-error.ts';
 
 export function registerCwdRoute(app: Hono) {

package/src/routes/config/main.ts

@@ -1,7 +1,7 @@
 import type { Hono } from 'hono';
 import { loadConfig } from '@agi-cli/sdk';
 import type { EmbeddedAppConfig } from '../../index.ts';
-import { logger } from '../../runtime/logger.ts';
+import { logger } from '@agi-cli/sdk';
 import { serializeError } from '../../runtime/api-error.ts';
 import {
 	discoverAllAgents,

package/src/routes/config/models.ts

@@ -1,7 +1,7 @@
 import type { Hono } from 'hono';
 import { loadConfig, catalog, type ProviderId } from '@agi-cli/sdk';
 import type { EmbeddedAppConfig } from '../../index.ts';
-import { logger } from '../../runtime/logger.ts';
+import { logger } from '@agi-cli/sdk';
 import { serializeError } from '../../runtime/api-error.ts';
 import {
 	isProviderAuthorizedHybrid,

package/src/routes/config/providers.ts

@@ -2,7 +2,7 @@ import type { Hono } from 'hono';
 import { loadConfig } from '@agi-cli/sdk';
 import type { ProviderId } from '@agi-cli/sdk';
 import type { EmbeddedAppConfig } from '../../index.ts';
-import { logger } from '../../runtime/logger.ts';
+import { logger } from '@agi-cli/sdk';
 import { serializeError } from '../../runtime/api-error.ts';
 import { getAuthorizedProviders, getDefault } from './utils.ts';
 

package/src/routes/config/utils.ts

@@ -8,7 +8,7 @@ import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import type { EmbeddedAppConfig } from '../../index.ts';
 import type { AGIConfig } from '@agi-cli/sdk';
-import { logger } from '../../runtime/logger.ts';
+import { logger } from '@agi-cli/sdk';
 import { loadAgentsConfig } from '../../runtime/agent-registry.ts';
 
 export async function isProviderAuthorizedHybrid(

package/src/routes/files.ts

@@ -4,7 +4,7 @@ import { join, relative } from 'node:path';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { serializeError } from '../runtime/api-error.ts';
-import { logger } from '../runtime/logger.ts';
+import { logger } from '@agi-cli/sdk';
 
 const execAsync = promisify(exec);
 

package/src/routes/session-messages.ts

@@ -9,7 +9,7 @@ import {
 	ensureProviderEnv,
 } from '@agi-cli/sdk';
 import { dispatchAssistantMessage } from '../runtime/message-service.ts';
-import { logger } from '../runtime/logger.ts';
+import { logger } from '@agi-cli/sdk';
 import { serializeError } from '../runtime/api-error.ts';
 
 type MessagePartRow = typeof messageParts.$inferSelect;

package/src/routes/sessions.ts

@@ -8,7 +8,7 @@ import { isProviderId, catalog } from '@agi-cli/sdk';
 import { resolveAgentConfig } from '../runtime/agent-registry.ts';
 import { createSession as createSessionRow } from '../runtime/session-manager.ts';
 import { serializeError } from '../runtime/api-error.ts';
-import { logger } from '../runtime/logger.ts';
+import { logger } from '@agi-cli/sdk';
 
 export function registerSessionsRoutes(app: Hono) {
 	// List sessions

package/src/routes/terminals.ts

@@ -1,6 +1,7 @@
 import type { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import type { TerminalManager } from '@agi-cli/sdk';
+import { logger } from '@agi-cli/sdk';
 
 export function registerTerminalsRoutes(
 	app: Hono,
@@ -16,9 +17,9 @@ export function registerTerminalsRoutes(
 
 	app.post('/v1/terminals', async (c) => {
 		try {
-			console.log('[API] POST /v1/terminals called');
+			logger.debug('POST /v1/terminals called');
 			const body = await c.req.json();
-			console.log('[API] Request body:', body);
+			logger.debug('Creating terminal request received', body);
 			const { command, args, purpose, cwd, title } = body;
 
 			if (!command || !purpose) {
@@ -31,7 +32,7 @@ export function registerTerminalsRoutes(
 			}
 			const resolvedCwd = cwd || process.cwd();
 
-			console.log('[API] Creating terminal with:', {
+			logger.debug('Creating terminal', {
 				command: resolvedCommand,
 				args,
 				purpose,
@@ -47,7 +48,7 @@ export function registerTerminalsRoutes(
 				title,
 			});
 
-			console.log('[API] Terminal created successfully:', terminal.id);
+			logger.debug('Terminal created successfully', { id: terminal.id });
 
 			return c.json({
 				terminalId: terminal.id,
@@ -56,11 +57,7 @@ export function registerTerminalsRoutes(
 				command: terminal.command,
 			});
 		} catch (error) {
-			console.error('[API] Error creating terminal:', error);
-			console.error(
-				'[API] Error stack:',
-				error instanceof Error ? error.stack : 'No stack',
-			);
+			logger.error('Error creating terminal', error);
 			const message = error instanceof Error ? error.message : String(error);
 			return c.json({ error: message }, 500);
 		}
@@ -79,21 +76,24 @@ export function registerTerminalsRoutes(
 
 	app.get('/v1/terminals/:id/output', async (c) => {
 		const id = c.req.param('id');
-		console.log('[SSE] Client connecting to terminal:', id);
+		logger.debug('SSE client connecting to terminal', { id });
 		const terminal = terminalManager.get(id);
 
 		if (!terminal) {
-			console.error('[SSE] Terminal not found:', id);
+			logger.debug('SSE terminal not found', { id });
 			return c.json({ error: 'Terminal not found' }, 404);
 		}
 
 		return streamSSE(c, async (stream) => {
-			console.log('[SSE] Stream started for terminal:', id);
+			logger.debug('SSE stream started for terminal', { id });
 			// Send historical buffer first (unless skipHistory is set)
 			const skipHistory = c.req.query('skipHistory') === 'true';
 			if (!skipHistory) {
 				const history = terminal.read();
-				console.log('[SSE] Sending history, lines:', history.length);
+				logger.debug('SSE sending terminal history', {
+					id,
+					lines: history.length,
+				});
 				for (const line of history) {
 					await stream.write(
 						`data: ${JSON.stringify({ type: 'data', line })}\n\n`,
@@ -105,7 +105,7 @@ export function registerTerminalsRoutes(
 				try {
 					await stream.write(`data: ${JSON.stringify(payload)}\n\n`);
 				} catch (error) {
-					console.error('[SSE] Error writing event:', error);
+					logger.error('SSE error writing event', error, { id });
 				}
 			};
 
@@ -141,7 +141,9 @@ export function registerTerminalsRoutes(
 			}
 
 			function onAbort() {
-				console.log('[SSE] Client disconnected:', terminal.id);
+				logger.debug('SSE client disconnected from terminal', {
+					id: terminal.id,
+				});
 				stream.close();
 				finish();
 			}

package/src/runtime/debug-state.ts

@@ -23,6 +23,18 @@ const state: DebugState = {
 	runtimeTraceOverride: null,
 };
 
+type GlobalDebugFlags = {
+	__AGI_DEBUG_ENABLED__?: boolean;
+	__AGI_TRACE_ENABLED__?: boolean;
+};
+
+const globalFlags = globalThis as GlobalDebugFlags;
+
+function syncGlobalFlags() {
+	globalFlags.__AGI_DEBUG_ENABLED__ = state.enabled;
+	globalFlags.__AGI_TRACE_ENABLED__ = state.traceEnabled;
+}
+
 /**
  * Check if environment variables indicate debug mode
  */
@@ -63,6 +75,7 @@ function initialize() {
 	if (state.runtimeTraceOverride === null) {
 		state.traceEnabled = checkEnvTrace();
 	}
+	syncGlobalFlags();
 }
 
 /**
@@ -92,6 +105,7 @@ export function isTraceEnabled(): boolean {
 export function setDebugEnabled(enabled: boolean): void {
 	state.enabled = enabled;
 	state.runtimeOverride = enabled;
+	syncGlobalFlags();
 }
 
 /**
@@ -103,6 +117,7 @@ export function setDebugEnabled(enabled: boolean): void {
 export function setTraceEnabled(enabled: boolean): void {
 	state.traceEnabled = enabled;
 	state.runtimeTraceOverride = enabled;
+	syncGlobalFlags();
 }
 
 /**
@@ -113,6 +128,7 @@ export function resetDebugState(): void {
 	state.runtimeTraceOverride = null;
 	state.enabled = checkEnvDebug();
 	state.traceEnabled = checkEnvTrace();
+	syncGlobalFlags();
 }
 
 /**

package/src/runtime/debug.ts

@@ -6,7 +6,7 @@
  */
 
 import { isDebugEnabled as isDebugEnabledNew } from './debug-state';
-import { time as timeNew, debug as debugNew } from './logger';
+import { time as timeNew, debug as debugNew } from '@agi-cli/sdk';
 
 const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
 

package/src/runtime/tool-context-setup.ts

@@ -31,6 +31,7 @@ export async function setupToolContext(
 		provider: opts.provider,
 		model: opts.model,
 		projectRoot: opts.projectRoot,
+		stepExecution: { states: new Map() },
 		onFirstToolCall: () => {
 			if (firstToolSeen) return;
 			firstToolSeen = true;

package/src/runtime/tool-context.ts

@@ -3,6 +3,11 @@ import type { DB } from '@agi-cli/database';
 import { messageParts } from '@agi-cli/database/schema';
 import { publish } from '../events/bus.ts';
 
+export type StepExecutionState = {
+	chain: Promise<void>;
+	failed: boolean;
+};
+
 export type ToolAdapterContext = {
 	sessionId: string;
 	messageId: string;
@@ -15,6 +20,9 @@ export type ToolAdapterContext = {
 	nextIndex: () => number | Promise<number>;
 	stepIndex?: number;
 	onFirstToolCall?: () => void;
+	stepExecution?: {
+		states: Map<number, StepExecutionState>;
+	};
 };
 
 export function extractFinishText(input: unknown): string | undefined {

package/src/tools/adapter.ts

@@ -4,7 +4,10 @@ import { eq } from 'drizzle-orm';
 import { publish } from '../events/bus.ts';
 import type { DiscoveredTool } from '@agi-cli/sdk';
 import { getCwd, setCwd, joinRelative } from '../runtime/cwd.ts';
-import type { ToolAdapterContext } from '../runtime/tool-context.ts';
+import type {
+	ToolAdapterContext,
+	StepExecutionState,
+} from '../runtime/tool-context.ts';
 import { isToolError } from '@agi-cli/sdk/tools/error';
 
 export type { ToolAdapterContext } from '../runtime/tool-context.ts';
@@ -49,6 +52,11 @@ export function adaptTools(
 	const pendingCalls = new Map<string, PendingCallMeta[]>();
 	let firstToolCallReported = false;
 
+	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']);
@@ -57,6 +65,68 @@ export function adaptTools(
 	for (const { name, tool } of tools) {
 		const base = tool;
 
+		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' &&
@@ -212,263 +282,282 @@ export function adaptTools(
 				const startTsFromQueue = meta?.startTs;
 				const stepIndexForEvent = meta?.stepIndex ?? ctx.stepIndex;
 
-				try {
-					// 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);
+				const stepKey =
+					typeof stepIndexForEvent === 'number' &&
+					Number.isFinite(stepIndexForEvent)
+						? stepIndexForEvent
+						: 0;
+				let stepState = stepStates.get(stepKey);
+				if (!stepState) {
+					stepState = { chain: Promise.resolve(), failed: false };
+					stepStates.set(stepKey, stepState);
+				}
+
+				const executeWithGuards = async (): Promise<ToolExecuteReturn> => {
+					try {
+						if (stepState.failed) {
+							const skipError = {
+								ok: false,
+								error: `Cannot execute "${name}" because a previous tool call in this step failed. Retry the failing tool before continuing with "${name}".`,
+								details: { skippedTool: name },
+							};
+							throw skipError;
+						}
+						// 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,
+									},
+								});
+							}
+							// 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;
+							await persistToolErrorResult(result, {
+								callId: callIdFromQueue,
+								startTs: startTsFromQueue,
+								stepIndexForEvent,
+								args: meta?.args,
+							});
+							processedToolErrors.add(result as object);
+							throw result;
+						}
+
+						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') {
 							publish({
-								type: 'tool.delta',
+								type: 'tool.result',
 								sessionId: ctx.sessionId,
-								payload: {
-									name,
-									channel: 'output',
-									delta: chunk,
-									stepIndex: stepIndexForEvent,
-									callId: callIdFromQueue,
-								},
+								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;
 						}
-						// 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);
-					}
-					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) {
+
+						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 maybeArtifact = (result as { artifact?: unknown }).artifact;
-							if (maybeArtifact !== undefined)
-								contentObj.artifact = maybeArtifact;
+							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 {}
-					}
-
-					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') {
 						publish({
 							type: 'tool.result',
 							sessionId: ctx.sessionId,
 							payload: { ...contentObj, stepIndex: stepIndexForEvent },
 						});
-						// Persist without blocking the event loop
-						(async () => {
+						if (name === 'update_plan') {
 							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,
-								});
+								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;
 
-					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));
+						// Tool execution failed
+						if (
+							isToolError(error) &&
+							processedToolErrors.has(error as object)
+						) {
+							throw error;
 						}
-					} catch {}
-					publish({
-						type: 'tool.result',
-						sessionId: ctx.sessionId,
-						payload: { ...contentObj, stepIndex: stepIndexForEvent },
-					});
-					if (name === 'update_plan') {
-						try {
-							const result = (contentObj as { result?: unknown }).result as
-								| { items?: unknown; note?: unknown }
-								| undefined;
-							if (result && Array.isArray(result.items)) {
-								publish({
-									type: 'plan.updated',
-									sessionId: ctx.sessionId,
-									payload: { items: result.items, note: result.note },
-								});
-							}
-						} catch {}
-					}
-					return result;
-				} catch (error) {
-					// Tool execution failed
-					// Check if the error is already a structured tool error response
-					const resultPartId = crypto.randomUUID();
-					const callId = callIdFromQueue;
-					const startTs = startTsFromQueue;
-					const endTs = Date.now();
-					const dur =
-						typeof startTs === 'number' ? Math.max(0, endTs - startTs) : null;
-
-					// If the tool returned a structured error response, use it directly
-					// Otherwise, wrap the thrown error in our standard format
-					let errorResult: unknown;
-					if (isToolError(error)) {
-						errorResult = error;
-					} else {
-						const errorMessage =
-							error instanceof Error ? error.message : String(error);
-						const errorStack = error instanceof Error ? error.stack : undefined;
-						errorResult = {
-							ok: false,
-							error: errorMessage,
-							stack: errorStack,
-						};
-					}
 
-					const contentObj = {
-						name,
-						result: errorResult,
-						callId,
-					};
+						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,
+									};
+								})();
 
-					if (meta?.args !== undefined) {
-						contentObj.args = meta.args;
-					}
+						await persistToolErrorResult(errorResult, {
+							callId: callIdFromQueue,
+							startTs: startTsFromQueue,
+							stepIndexForEvent,
+							args: meta?.args,
+						});
 
-					const index = await ctx.nextIndex();
-
-					// Save error result to database
-					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,
-					});
+						if (isToolError(error)) {
+							processedToolErrors.add(error as object);
+						}
 
-					// Publish error result
-					publish({
-						type: 'tool.result',
-						sessionId: ctx.sessionId,
-						payload: { ...contentObj, stepIndex: stepIndexForEvent },
-					});
+						// Re-throw so AI SDK can handle it
+						throw error;
+					}
+				};
 
-					// Re-throw so AI SDK can handle it
-					throw error;
-				}
+				const queued = stepState.chain
+					.catch(() => undefined)
+					.then(() => executeWithGuards());
+				stepState.chain = queued.then(
+					() => undefined,
+					() => undefined,
+				);
+				return queued;
 			},
 		} as Tool;
 	}

package/src/runtime/logger.ts

@@ -1,206 +0,0 @@
-/**
- * Centralized logging utility
- *
- * Provides structured logging with debug mode awareness.
- * Replaces scattered console.log calls throughout the codebase.
- */
-
-import { isDebugEnabled, isTraceEnabled } from './debug-state';
-
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-
-/**
- * Format a log message with optional metadata
- */
-function _formatMessage(
-	level: LogLevel,
-	message: string,
-	meta?: Record<string, unknown>,
-): string {
-	const timestamp = new Date().toISOString();
-	const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
-
-	if (meta && Object.keys(meta).length > 0) {
-		return `${prefix} ${message} ${JSON.stringify(meta)}`;
-	}
-
-	return `${prefix} ${message}`;
-}
-
-/**
- * Log at debug level (only when debug mode is enabled)
- */
-export function debug(message: string, meta?: Record<string, unknown>): void {
-	if (!isDebugEnabled()) return;
-
-	try {
-		if (meta && Object.keys(meta).length > 0) {
-			console.log(`[debug] ${message}`, meta);
-		} else {
-			console.log(`[debug] ${message}`);
-		}
-	} catch {
-		// Silently fail
-	}
-}
-
-/**
- * Log informational messages (only when debug or trace mode is enabled)
- */
-export function info(message: string, meta?: Record<string, unknown>): void {
-	if (!isDebugEnabled() && !isTraceEnabled()) return;
-
-	try {
-		if (meta && Object.keys(meta).length > 0) {
-			console.log(`[info] ${message}`, meta);
-		} else {
-			console.log(`[info] ${message}`);
-		}
-	} catch {
-		// Silently fail
-	}
-}
-
-/**
- * Log warning messages
- */
-export function warn(message: string, meta?: Record<string, unknown>): void {
-	try {
-		if (meta && Object.keys(meta).length > 0) {
-			console.warn(`[warn] ${message}`, meta);
-		} else {
-			console.warn(`[warn] ${message}`);
-		}
-	} catch {
-		// Silently fail
-	}
-}
-
-/**
- * Log error messages (only in debug mode, stack trace only with --trace)
- */
-export function error(
-	message: string,
-	err?: unknown,
-	meta?: Record<string, unknown>,
-): void {
-	// Only log errors when debug mode is enabled
-	if (!isDebugEnabled()) return;
-
-	try {
-		const logMeta: Record<string, unknown> = { ...meta };
-
-		if (err) {
-			if (err instanceof Error) {
-				// Always show error name and message in debug mode
-				logMeta.error = {
-					name: err.name,
-					message: err.message,
-				};
-
-				// Show full stack trace only with --trace flag
-				if (isTraceEnabled() && err.stack) {
-					logMeta.error.stack = err.stack;
-				}
-			} else if (typeof err === 'string') {
-				logMeta.error = err;
-			} else if (err && typeof err === 'object') {
-				// For other error objects, try to extract useful info
-				const errObj = err as Record<string, unknown>;
-				logMeta.error = {
-					...(typeof errObj.name === 'string' ? { name: errObj.name } : {}),
-					...(typeof errObj.message === 'string'
-						? { message: errObj.message }
-						: {}),
-					...(typeof errObj.code === 'string' ? { code: errObj.code } : {}),
-					...(typeof errObj.status === 'number'
-						? { status: errObj.status }
-						: {}),
-					...(typeof errObj.statusCode === 'number'
-						? { statusCode: errObj.statusCode }
-						: {}),
-				};
-
-				// Include stack in trace mode
-				if (isTraceEnabled() && typeof errObj.stack === 'string') {
-					logMeta.error.stack = errObj.stack;
-				}
-			} else {
-				// Fallback for primitive types
-				logMeta.error = String(err);
-			}
-		}
-
-		if (Object.keys(logMeta).length > 0) {
-			console.error(`[error] ${message}`, logMeta);
-		} else {
-			console.error(`[error] ${message}`);
-		}
-	} catch (logErr) {
-		// Last resort: at least try to log something
-		try {
-			console.error(`[error] ${message} (logging failed:`, logErr, ')');
-		} catch {
-			// Give up silently
-		}
-	}
-}
-
-/**
- * Logger object with all methods
- */
-export const logger = {
-	debug,
-	info,
-	warn,
-	error,
-};
-
-/**
- * Timing utilities (integrates with existing debug.ts timing)
- */
-function nowMs(): number {
-	const perf = (globalThis as { performance?: { now?: () => number } })
-		.performance;
-	if (perf && typeof perf.now === 'function') return perf.now();
-	return Date.now();
-}
-
-type Timer = {
-	end(meta?: Record<string, unknown>): void;
-};
-
-/**
- * Create a timer for performance measurement
- * Only active when debug mode is enabled
- */
-export function time(label: string): Timer {
-	if (!isDebugEnabled()) {
-		return { end() {} };
-	}
-
-	const start = nowMs();
-	let finished = false;
-
-	return {
-		end(meta?: Record<string, unknown>) {
-			if (finished) return;
-			finished = true;
-			const duration = nowMs() - start;
-
-			try {
-				const line = `[timing] ${label} ${duration.toFixed(1)}ms`;
-				if (meta && Object.keys(meta).length) {
-					console.log(line, meta);
-				} else {
-					console.log(line);
-				}
-			} catch {
-				// Silently fail
-			}
-		},
-	};
-}
-
-// Export legacy compatibility
-export { isDebugEnabled, isTraceEnabled };