@roj-ai/sdk 0.1.36 → 0.2.2

package/src/core/image/types.ts

@@ -5,6 +5,8 @@ export interface ImageResizeOptions {
 	maxFileSizeBytes?: number
 	/** Override the resizer's default max dimension (long side, px). */
 	maxDimension?: number
+	/** Cancels external image-processing commands. */
+	signal?: AbortSignal
 }
 
 export interface ImageResizer {

package/src/core/image/vips-resizer.ts

@@ -25,31 +25,59 @@ export class VipsImageResizer implements ImageResizer {
 
 	async resize(filePath: string, mimeType: string, options?: ImageResizeOptions): Promise<ImageResizeResult> {
 		const effectiveMaxDimension = options?.maxDimension ?? this.maxDimension
+		const signal = options?.signal
+		let ownedTempFile: string | undefined
 		try {
+			signal?.throwIfAborted()
 			// Step 1: Dimension resize if needed
-			const result = await this.dimensionResize(filePath, mimeType, effectiveMaxDimension)
+			const result = await this.dimensionResize(filePath, mimeType, effectiveMaxDimension, signal)
+			ownedTempFile = result.tempFile
+			signal?.throwIfAborted()
 
 			// Step 2: If no size constraint, done
-			if (!options?.maxFileSizeBytes) return result
+			if (!options?.maxFileSizeBytes) {
+				signal?.throwIfAborted()
+				return result
+			}
 
 			// Step 3: Check if result fits
 			const fileSize = (await this.fs.stat(result.path)).size
-			if (fileSize <= options.maxFileSizeBytes) return result
+			signal?.throwIfAborted()
+			if (fileSize <= options.maxFileSizeBytes) {
+				signal?.throwIfAborted()
+				return result
+			}
 
 			// Step 4: Compress to fit — clean up dimension resize temp first
 			if (result.tempFile) {
 				await this.fs.unlink(result.tempFile).catch(() => {})
+				ownedTempFile = undefined
 			}
 
-			return await this.compressToFit(filePath, options.maxFileSizeBytes, effectiveMaxDimension)
+			signal?.throwIfAborted()
+			const compressed = await this.compressToFit(filePath, options.maxFileSizeBytes, effectiveMaxDimension, signal)
+			ownedTempFile = compressed.tempFile
+			signal?.throwIfAborted()
+			return compressed
 		} catch (e) {
+			if (ownedTempFile) {
+				await this.fs.unlink(ownedTempFile).catch(() => {})
+			}
+			if (signal?.aborted) signal.throwIfAborted()
 			console.warn('[image-resize] failed, using original image:', e instanceof Error ? e.message : e)
 			return { path: filePath, mimeType }
 		}
 	}
 
-	private async getImageDimensions(filePath: string): Promise<{ width: number; height: number } | null> {
-		const { stdout } = await this.process.execFile('vipsheader', ['-f', 'width', '-f', 'height', filePath], { timeout: 30_000 })
+	private async getImageDimensions(
+		filePath: string,
+		signal?: AbortSignal,
+	): Promise<{ width: number; height: number } | null> {
+		const { stdout } = await this.process.execFile('vipsheader', ['-f', 'width', '-f', 'height', filePath], {
+			timeout: 30_000,
+			signal,
+		})
+		signal?.throwIfAborted()
 		const lines = stdout.trim().split('\n')
 		if (lines.length < 2) return null
 		const width = parseInt(lines[0], 10)
@@ -58,12 +86,19 @@ export class VipsImageResizer implements ImageResizer {
 		return { width, height }
 	}
 
-	private async dimensionResize(filePath: string, mimeType: string, maxDimension: number): Promise<ImageResizeResult> {
-		const dims = await this.getImageDimensions(filePath)
+	private async dimensionResize(
+		filePath: string,
+		mimeType: string,
+		maxDimension: number,
+		signal?: AbortSignal,
+	): Promise<ImageResizeResult> {
+		const dims = await this.getImageDimensions(filePath, signal)
+		signal?.throwIfAborted()
 		const needsResize = dims !== null && (dims.width > maxDimension || dims.height > maxDimension)
 
 		// JPEGs within dimension limits pass through unchanged
 		if (mimeType === 'image/jpeg' && !needsResize) {
+			signal?.throwIfAborted()
 			return { path: filePath, mimeType }
 		}
 
@@ -71,17 +106,27 @@ export class VipsImageResizer implements ImageResizer {
 		const id = `${Date.now()}-${Math.random().toString(36).slice(2)}`
 		const outputPath = join(this.tmpDir, `roj-resize-${id}.jpg`)
 
-		await this.process.execFile('vipsthumbnail', [
-			filePath,
-			'--size',
-			`${maxDimension}x${maxDimension}`,
-			'-o',
-			outputPath,
-		], { timeout: 30_000 })
+		try {
+			await this.process.execFile(
+				'vipsthumbnail',
+				[filePath, '--size', `${maxDimension}x${maxDimension}`, '-o', outputPath],
+				{ timeout: 30_000, signal },
+			)
+			signal?.throwIfAborted()
+		} catch (error) {
+			await this.fs.unlink(outputPath).catch(() => {})
+			throw error
+		}
+		signal?.throwIfAborted()
 		return { path: outputPath, mimeType: 'image/jpeg', tempFile: outputPath }
 	}
 
-	private async compressToFit(filePath: string, maxFileSizeBytes: number, maxDimension: number): Promise<ImageResizeResult> {
+	private async compressToFit(
+		filePath: string,
+		maxFileSizeBytes: number,
+		maxDimension: number,
+		signal?: AbortSignal,
+	): Promise<ImageResizeResult> {
 		const halfDim = Math.floor(maxDimension / 2)
 		const attempts = [
 			{ dimension: maxDimension, quality: 85 },
@@ -95,31 +140,51 @@ export class VipsImageResizer implements ImageResizer {
 
 		let lastResult: ImageResizeResult | undefined
 
-		for (const { dimension, quality } of attempts) {
-			const id = `${Date.now()}-${Math.random().toString(36).slice(2)}`
-			const outputPath = join(this.tmpDir, `roj-compress-${id}.jpg`)
-
-			await this.process.execFile('vipsthumbnail', [
-				filePath,
-				'--size',
-				`${dimension}x${dimension}`,
-				'-o',
-				`${outputPath}[Q=${quality}]`,
-			], { timeout: 30_000 })
+		try {
+			for (const { dimension, quality } of attempts) {
+				signal?.throwIfAborted()
+				const id = `${Date.now()}-${Math.random().toString(36).slice(2)}`
+				const outputPath = join(this.tmpDir, `roj-compress-${id}.jpg`)
+
+				try {
+					await this.process.execFile(
+						'vipsthumbnail',
+						[filePath, '--size', `${dimension}x${dimension}`, '-o', `${outputPath}[Q=${quality}]`],
+						{ timeout: 30_000, signal },
+					)
+					signal?.throwIfAborted()
+
+					const outputSize = (await this.fs.stat(outputPath)).size
+					signal?.throwIfAborted()
+					if (lastResult?.tempFile) {
+						await this.fs.unlink(lastResult.tempFile).catch(() => {})
+					}
+					signal?.throwIfAborted()
+
+					lastResult = {
+						path: outputPath,
+						mimeType: 'image/jpeg',
+						tempFile: outputPath,
+					}
+					if (outputSize <= maxFileSizeBytes) {
+						signal?.throwIfAborted()
+						return lastResult
+					}
+				} catch (error) {
+					await this.fs.unlink(outputPath).catch(() => {})
+					throw error
+				}
+			}
 
-			// Clean up previous attempt
+			// Return best effort (most compressed) — caller decides what to do
+			if (!lastResult) throw new Error('Image compression produced no result')
+			signal?.throwIfAborted()
+			return lastResult
+		} catch (error) {
 			if (lastResult?.tempFile) {
 				await this.fs.unlink(lastResult.tempFile).catch(() => {})
 			}
-
-			lastResult = { path: outputPath, mimeType: 'image/jpeg', tempFile: outputPath }
-
-			if ((await this.fs.stat(outputPath)).size <= maxFileSizeBytes) {
-				return lastResult
-			}
+			throw error
 		}
-
-		// Return best effort (most compressed) — caller decides what to do
-		return lastResult!
 	}
 }

package/src/core/llm/anthropic.ts

@@ -17,7 +17,9 @@ import type {
 	RawInferenceRequest,
 	RawToolSpec,
 } from './provider.js'
-import { ProviderMessageValidationError, sanitizeProviderMessages } from './message-sanitization.js'
+import { mapProviderError } from './provider.js'
+import { ProviderRequestAbortError, runProviderRequest } from './provider-request.js'
+import { sanitizeProviderMessages } from './message-sanitization.js'
 import type { RoutableLLMProvider } from './routing-provider.js'
 
 // ============================================================================
@@ -290,18 +292,8 @@ export class AnthropicProvider implements RoutableLLMProvider {
 			}
 
 			const httpRequest = await this.buildHttpRequest(rawRequest, context)
-
-			const controller = new AbortController()
-			const timeoutId = setTimeout(() => controller.abort(), this.timeout)
-
-			// Combine with external signal if provided
-			if (context?.signal) {
-				context.signal.addEventListener('abort', () => controller.abort(), { once: true })
-			}
-
-			let response: Response
-			try {
-				response = await this.fetchFn(httpRequest.url, {
+			return await runProviderRequest({ callerSignal: context?.signal, timeoutMs: this.timeout }, async (signal) => {
+				const response = await this.fetchFn(httpRequest.url, {
 					method: httpRequest.method,
 					headers: {
 						...httpRequest.headers,
@@ -309,66 +301,70 @@ export class AnthropicProvider implements RoutableLLMProvider {
 						'anthropic-dangerous-direct-browser-access': 'true',
 					},
 					body: JSON.stringify(httpRequest.body),
-					signal: controller.signal,
+					signal,
 				})
-			} finally {
-				clearTimeout(timeoutId)
-			}
 
-			if (!response.ok) {
-				const body = await response.text()
-				return Err(this.mapHttpError(response.status, body))
-			}
+				if (!response.ok) {
+					const body = await response.text()
+					return Err(this.mapHttpError(response.status, body))
+				}
 
-			const data = await response.json() as AnthropicMessageResponse
-			const latencyMs = Date.now() - startTime
-
-			const textContent = data.content
-				.filter((block): block is AnthropicTextBlock => block.type === 'text')
-				.map((block) => block.text)
-				.join('')
-
-			// Kept whole, in order, signatures included: the API verifies them on replay.
-			// `redacted_thinking` has no readable text but still has to travel.
-			const thinkingBlocks = data.content.filter(isThinkingBlock)
-
-			const reasoning = thinkingBlocks
-				.filter((block): block is AnthropicThinkingBlock => block.type === 'thinking')
-				.map((block) => block.thinking)
-				.join('')
-
-			const toolCalls: ToolCall[] = data.content
-				.filter((block): block is AnthropicToolUseBlock => block.type === 'tool_use')
-				.map((block) => ({
-					id: ToolCallId(block.id),
-					name: block.name,
-					input: block.input,
-				}))
-
-			const metrics: LLMMetrics = {
-				promptTokens: data.usage.input_tokens,
-				completionTokens: data.usage.output_tokens,
-				totalTokens: data.usage.input_tokens + data.usage.output_tokens,
-				latencyMs,
-				model: data.model,
-				provider: this.name,
-				cost: this.calculateCost(data.model, data.usage),
-				cachedTokens: data.usage.cache_read_input_tokens || undefined,
-				cacheWriteTokens: data.usage.cache_creation_input_tokens || undefined,
-			}
+				const data = await response.json() as AnthropicMessageResponse
+				const latencyMs = Date.now() - startTime
+
+				const textContent = data.content
+					.filter((block): block is AnthropicTextBlock => block.type === 'text')
+					.map((block) => block.text)
+					.join('')
+
+				// Kept whole, in order, signatures included: the API verifies them on replay.
+				// `redacted_thinking` has no readable text but still has to travel.
+				const thinkingBlocks = data.content.filter(isThinkingBlock)
+
+				const reasoning = thinkingBlocks
+					.filter((block): block is AnthropicThinkingBlock => block.type === 'thinking')
+					.map((block) => block.thinking)
+					.join('')
+
+				const toolCalls: ToolCall[] = data.content
+					.filter((block): block is AnthropicToolUseBlock => block.type === 'tool_use')
+					.map((block) => ({
+						id: ToolCallId(block.id),
+						name: block.name,
+						input: block.input,
+					}))
+
+				const metrics: LLMMetrics = {
+					promptTokens: data.usage.input_tokens,
+					completionTokens: data.usage.output_tokens,
+					totalTokens: data.usage.input_tokens + data.usage.output_tokens,
+					latencyMs,
+					model: data.model,
+					provider: this.name,
+					cost: this.calculateCost(data.model, data.usage),
+					cachedTokens: data.usage.cache_read_input_tokens || undefined,
+					cacheWriteTokens: data.usage.cache_creation_input_tokens || undefined,
+				}
 
-			return Ok({
-				content: textContent || null,
-				toolCalls,
-				finishReason: this.mapStopReason(data.stop_reason),
-				metrics,
-				providerRequestId: data.id,
-				reasoning: reasoning || undefined,
-				// Normalized to undefined so an empty array never reaches the wire on the way back.
-				thinkingBlocks: thinkingBlocks.length > 0 ? thinkingBlocks : undefined,
+				return Ok({
+					content: textContent || null,
+					toolCalls,
+					finishReason: this.mapStopReason(data.stop_reason),
+					metrics,
+					providerRequestId: data.id,
+					reasoning: reasoning || undefined,
+					// Normalized to undefined so an empty array never reaches the wire on the way back.
+					thinkingBlocks: thinkingBlocks.length > 0 ? thinkingBlocks : undefined,
+				})
 			})
 		} catch (error) {
-			return Err(this.mapError(error))
+			if (error instanceof ProviderRequestAbortError) {
+				return Err({
+					type: error.abortCause === 'caller' ? 'aborted' : 'timeout',
+					message: error.message,
+				})
+			}
+			return Err(mapProviderError(error))
 		}
 	}
 
@@ -642,16 +638,4 @@ export class AnthropicProvider implements RoutableLLMProvider {
 		return { type: 'server_error', message, statusCode: status, responseBody: body }
 	}
 
-	private mapError(err: unknown): LLMError {
-		if (err instanceof ProviderMessageValidationError) {
-			return { type: 'invalid_request', message: err.message }
-		}
-		if (err instanceof Error && err.name === 'AbortError') {
-			return { type: 'aborted', message: 'Request was aborted' }
-		}
-		if (err instanceof TypeError && (err.message.includes('fetch') || err.message.includes('network'))) {
-			return { type: 'network_error', message: err.message, cause: err }
-		}
-		return { type: 'network_error', message: err instanceof Error ? err.message : String(err), cause: err }
-	}
 }

package/src/core/llm/logger.ts

@@ -5,13 +5,20 @@
  * Per spec.md 9.1: "Pro debugging a audit se bude logovat kompletní LLM komunikace"
  *
  * Calls are stored in the session folder: {dataPath}/sessions/{sessionId}/calls/
+ *
+ * A host that has a table for them ({@link LLMCallStore}) gets rows instead: the
+ * same entries, but `completeCall` stops reading the whole entry back to rewrite
+ * it and `listCalls` stops being a `readdir` plus one read per row of the page.
+ * Without a store nothing changes — same directory, same files, same content.
  */
 
 import { join } from 'node:path'
-import type { AgentId } from '~/core/agents/schema.js'
+import { AgentId } from '~/core/agents/schema.js'
 import { generateLLMCallId, LLMCallId } from '~/core/llm/schema.js'
 import type { SessionId } from '~/core/sessions/schema.js'
+import { readTextFilesOrUndefined } from '~/lib/utils/fs-batch.js'
 import type { FileSystem } from '~/platform/fs.js'
+import type { LLMCallRow, LLMCallStore } from '~/platform/llm-call-log.js'
 import type { LLMCallError, LLMCallLogEntry, LLMCallMessage, LLMCallMetrics, LLMCallRequest, LLMCallResponse } from './llm-log-types.js'
 import type { InferenceRequest, InferenceResponse, LLMError } from './provider.js'
 
@@ -27,6 +34,70 @@ export interface LLMLoggerConfig {
 	basePath: string
 	enabled: boolean
 	fs: FileSystem
+	/** Rows instead of files, where the host has a table for them. */
+	store?: LLMCallStore
+}
+
+const ENCODER = new TextEncoder()
+
+/** UTF-8 length; the SDK cannot assume `Buffer`. */
+function byteLength(text: string): number {
+	return ENCODER.encode(text).byteLength
+}
+
+/**
+ * Fit a request inside the host's column ceiling.
+ *
+ * Everything in a request is bounded by the agent definition except the message
+ * history, which grows with the session and carries whole tool results. Over the
+ * ceiling the store would reject the row and, because `createCall` is awaited on
+ * the inference path, turn a logged call into a failed one.
+ */
+function clampRequest(request: LLMCallRequest, maxBytes: number | undefined): string {
+	const json = JSON.stringify(request)
+	// UTF-8 is at most 3 bytes per UTF-16 unit, so the common case never encodes.
+	if (maxBytes === undefined || json.length * 3 <= maxBytes) return json
+
+	const bytes = byteLength(json)
+	if (bytes <= maxBytes) return json
+
+	const dropped: LLMCallRequest = {
+		...request,
+		messages: [{
+			role: 'system',
+			content: `[${request.messages.length} messages, ${bytes} B, dropped: over the host's ${maxBytes} B column limit]`,
+		}],
+		tools: undefined,
+	}
+	const withoutMessages = JSON.stringify(dropped)
+	if (byteLength(withoutMessages) <= maxBytes) return withoutMessages
+
+	// A system prompt alone past the ceiling is pathological; keep only what a listing shows.
+	const minimal: LLMCallRequest = {
+		model: request.model,
+		systemPrompt: `[${byteLength(request.systemPrompt)} B, dropped]`,
+		messages: [],
+		toolsCount: request.tools?.length ?? 0,
+	}
+	return JSON.stringify(minimal)
+}
+
+/** JSON this logger wrote itself; annotated rather than cast, and never validated on read. */
+function parseJson<T>(json: string): T {
+	return JSON.parse(json)
+}
+
+function parseOptionalJson<T>(json: string | undefined): T | undefined {
+	return json === undefined ? undefined : parseJson<T>(json)
+}
+
+/** One stored entry, or null when the file stopped being JSON. */
+function parseEntry(content: string): LLMCallLogEntry | null {
+	try {
+		return parseJson<LLMCallLogEntry>(content)
+	} catch {
+		return null
+	}
 }
 
 // ============================================================================
@@ -35,14 +106,17 @@ export interface LLMLoggerConfig {
 
 /**
  * Logger for LLM requests and responses.
- * Stores individual JSON files per LLM call in the session folder.
+ * One JSON file per call in the session folder, or one row per call in a
+ * {@link LLMCallStore} where the host has one.
  */
 export class LLMLogger {
 	private dirCache = new Set<string>()
 	private readonly fs: FileSystem
+	private readonly store?: LLMCallStore
 
 	constructor(private config: LLMLoggerConfig) {
 		this.fs = config.fs
+		this.store = config.store
 	}
 
 	/**
@@ -138,6 +212,18 @@ export class LLMLogger {
 			providerOptions,
 		}
 
+		if (this.store !== undefined) {
+			await this.store.create(sessionId, {
+				callId,
+				agentId,
+				createdAt: now,
+				status: 'running',
+				model: request.model,
+				request: clampRequest(callRequest, this.store.maxBlobBytes),
+			})
+			return callId
+		}
+
 		const entry: LLMCallLogEntry = {
 			id: callId,
 			sessionId,
@@ -163,17 +249,6 @@ export class LLMLogger {
 		response: InferenceResponse,
 		durationMs: number,
 	): Promise<void> {
-		const filePath = this.getCallFilePath(sessionId, callId)
-
-		let entry: LLMCallLogEntry
-		try {
-			const content = await this.fs.readFile(filePath, 'utf-8')
-			entry = JSON.parse(content) as LLMCallLogEntry
-		} catch {
-			// File doesn't exist or is invalid - skip update
-			return
-		}
-
 		const callResponse: LLMCallResponse = {
 			content: response.content,
 			toolCalls: response.toolCalls.map((tc) => ({
@@ -199,6 +274,25 @@ export class LLMLogger {
 			reasoningTokens: response.metrics.reasoningTokens,
 		}
 
+		if (this.store !== undefined) {
+			// The whole reason for splitting the row: no read-back, and the request
+			// column is not in the SET list.
+			await this.store.complete(sessionId, callId, {
+				status: 'success',
+				completedAt: Date.now(),
+				durationMs,
+				providerRequestId: response.providerRequestId,
+				response: JSON.stringify(callResponse),
+				metrics: JSON.stringify(callMetrics),
+			})
+			return
+		}
+
+		const filePath = this.getCallFilePath(sessionId, callId)
+		const entry = await this.readEntry(filePath)
+		// File doesn't exist or is invalid - skip update
+		if (entry === null) return
+
 		entry.status = 'success'
 		entry.completedAt = Date.now()
 		entry.durationMs = durationMs
@@ -218,17 +312,6 @@ export class LLMLogger {
 		error: LLMError,
 		durationMs: number,
 	): Promise<void> {
-		const filePath = this.getCallFilePath(sessionId, callId)
-
-		let entry: LLMCallLogEntry
-		try {
-			const content = await this.fs.readFile(filePath, 'utf-8')
-			entry = JSON.parse(content) as LLMCallLogEntry
-		} catch {
-			// File doesn't exist or is invalid - skip update
-			return
-		}
-
 		const callError: LLMCallError = {
 			type: error.type,
 			message: error.message,
@@ -237,6 +320,21 @@ export class LLMLogger {
 			responseBody: error.responseBody,
 		}
 
+		if (this.store !== undefined) {
+			await this.store.complete(sessionId, callId, {
+				status: 'error',
+				completedAt: Date.now(),
+				durationMs,
+				error: JSON.stringify(callError),
+			})
+			return
+		}
+
+		const filePath = this.getCallFilePath(sessionId, callId)
+		const entry = await this.readEntry(filePath)
+		// File doesn't exist or is invalid - skip update
+		if (entry === null) return
+
 		entry.status = 'error'
 		entry.completedAt = Date.now()
 		entry.durationMs = durationMs
@@ -252,11 +350,18 @@ export class LLMLogger {
 		sessionId: SessionId,
 		callId: LLMCallId,
 	): Promise<LLMCallLogEntry | null> {
-		const filePath = this.getCallFilePath(sessionId, callId)
+		if (this.store !== undefined) {
+			const row = await this.store.get(sessionId, callId)
+			return row === null ? null : toEntry(sessionId, row)
+		}
+
+		return this.readEntry(this.getCallFilePath(sessionId, callId))
+	}
 
+	/** One stored entry, or null when the file has gone or stopped being JSON. */
+	private async readEntry(filePath: string): Promise<LLMCallLogEntry | null> {
 		try {
-			const content = await this.fs.readFile(filePath, 'utf-8')
-			return JSON.parse(content) as LLMCallLogEntry
+			return parseEntry(await this.fs.readFile(filePath, 'utf-8'))
 		} catch {
 			return null
 		}
@@ -269,6 +374,17 @@ export class LLMLogger {
 		sessionId: SessionId,
 		options?: { limit?: number; offset?: number },
 	): Promise<{ calls: LLMCallLogEntry[]; total: number }> {
+		const offset = options?.offset ?? 0
+		const limit = options?.limit ?? 100
+
+		if (this.store !== undefined) {
+			// One indexed query where the file path listed a directory, sorted the
+			// names and read the page's files one at a time. Same order, same page
+			// boundaries — see LLMCallStore.list.
+			const page = await this.store.list(sessionId, { limit, offset })
+			return { calls: page.calls.map((row) => toEntry(sessionId, row)), total: page.total }
+		}
+
 		const callsDir = join(this.config.basePath, 'sessions', sessionId, 'calls')
 
 		let files: string[]
@@ -286,21 +402,43 @@ export class LLMLogger {
 			.reverse() // Most recent first
 
 		const total = jsonFiles.length
-		const offset = options?.offset ?? 0
-		const limit = options?.limit ?? 100
 		const paginated = jsonFiles.slice(offset, offset + limit)
 
+		// The page is a known set of paths, so it is asked for as one where the
+		// platform takes one — the same read the store branch above replaces with
+		// a single query.
+		const contents = await readTextFilesOrUndefined(this.fs, paginated.map((file) => join(callsDir, file)))
+
 		const calls: LLMCallLogEntry[] = []
-		for (const file of paginated) {
-			try {
-				const filePath = join(callsDir, file)
-				const content = await this.fs.readFile(filePath, 'utf-8')
-				calls.push(JSON.parse(content) as LLMCallLogEntry)
-			} catch {
-				// Skip invalid files
-			}
+		for (const content of contents) {
+			// Skip invalid files
+			const entry = content === undefined ? null : parseEntry(content)
+			if (entry !== null) calls.push(entry)
 		}
 
 		return { calls, total }
 	}
 }
+
+/**
+ * Reassemble a stored row into the entry every reader is typed against.
+ *
+ * `sessionId` comes from the key rather than the row: it is what the caller
+ * looked the row up by, so storing it again would only be a second copy.
+ */
+function toEntry(sessionId: SessionId, row: LLMCallRow): LLMCallLogEntry {
+	return {
+		id: LLMCallId(row.callId),
+		sessionId,
+		agentId: AgentId(row.agentId),
+		createdAt: row.createdAt,
+		completedAt: row.completedAt,
+		durationMs: row.durationMs,
+		status: row.status,
+		request: parseJson<LLMCallRequest>(row.request),
+		response: parseOptionalJson<LLMCallResponse>(row.response),
+		metrics: parseOptionalJson<LLMCallMetrics>(row.metrics),
+		error: parseOptionalJson<LLMCallError>(row.error),
+		providerRequestId: row.providerRequestId,
+	}
+}