@roj-ai/sdk 0.0.2

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

@@ -0,0 +1,377 @@
+import { afterEach, describe, expect, it, mock, spyOn } from 'bun:test'
+import * as childProcess from 'node:child_process'
+
+type ExecFileCallback = (error: Error | null, stdout: string, stderr: string) => void
+let execFileImpl: (cmd: string, args: string[], opts: unknown, cb: ExecFileCallback) => void = () => {}
+
+mock.module('node:child_process', () => ({
+	...childProcess,
+	execFile: (cmd: string, args: string[], opts: unknown, cb: ExecFileCallback) => execFileImpl(cmd, args, opts, cb),
+}))
+
+const { VipsImageResizer } = await import('./vips-resizer.js')
+const { createNodePlatform } = await import('~/testing/node-platform.js')
+
+// Test-scoped helper — routes through createNodePlatform so the module-level
+// node:child_process mock still intercepts execFile calls made by ProcessRunner.
+function createResizer(maxDimension?: number): InstanceType<typeof VipsImageResizer> {
+	const platform = createNodePlatform()
+	return new VipsImageResizer({
+		fs: platform.fs,
+		process: platform.process,
+		tmpDir: platform.tmpDir,
+		maxDimension,
+	})
+}
+
+const warnSpy = spyOn(console, 'warn').mockImplementation(() => {})
+
+afterEach(() => {
+	warnSpy.mockClear()
+	execFileImpl = () => {}
+})
+
+describe('VipsImageResizer', () => {
+	const testJpegPath = '/tmp/test-image.jpg'
+
+	it('returns original path and mimeType when jpeg is within limits', async () => {
+		execFileImpl = (cmd, _args, _opts, cb) => {
+			if (cmd === 'vipsheader') cb(null, '4000\n3000\n', '')
+		}
+
+		const resizer = createResizer()
+		const result = await resizer.resize(testJpegPath, 'image/jpeg')
+
+		expect(result).toEqual({ path: testJpegPath, mimeType: 'image/jpeg' })
+	})
+
+	it('returns original path when jpeg is exactly at dimension limit', async () => {
+		execFileImpl = (cmd, _args, _opts, cb) => {
+			if (cmd === 'vipsheader') cb(null, '8000\n8000\n', '')
+		}
+
+		const resizer = createResizer()
+		const result = await resizer.resize(testJpegPath, 'image/jpeg')
+
+		expect(result).toEqual({ path: testJpegPath, mimeType: 'image/jpeg' })
+	})
+
+	it('converts png to jpeg even when within dimension limits', async () => {
+		execFileImpl = (cmd, _args, _opts, cb) => {
+			if (cmd === 'vipsheader') cb(null, '4000\n3000\n', '')
+			else if (cmd === 'vipsthumbnail') cb(null, '', '')
+		}
+
+		const resizer = createResizer()
+		const result = await resizer.resize('/tmp/test.png', 'image/png')
+
+		expect(result.path).toEndWith('.jpg')
+		expect(result.mimeType).toBe('image/jpeg')
+		expect(result.tempFile).toBeDefined()
+	})
+
+	it('calls vipsthumbnail and returns temp path when width exceeds limit', async () => {
+		let thumbnailArgs: string[] = []
+		execFileImpl = (cmd, args, _opts, cb) => {
+			if (cmd === 'vipsheader') cb(null, '10000\n5000\n', '')
+			else if (cmd === 'vipsthumbnail') {
+				thumbnailArgs = args
+				cb(null, '', '')
+			}
+		}
+
+		const resizer = createResizer()
+		const result = await resizer.resize('/tmp/test.png', 'image/png')
+
+		expect(result.path).not.toBe('/tmp/test.png')
+		expect(result.tempFile).toBe(result.path)
+		expect(result.path).toContain('roj-resize-')
+		expect(result.path).toEndWith('.jpg')
+		expect(result.mimeType).toBe('image/jpeg')
+		expect(thumbnailArgs).toContain('--size')
+		expect(thumbnailArgs).toContain('8000x8000')
+		expect(thumbnailArgs).toContain('/tmp/test.png')
+	})
+
+	it('calls vipsthumbnail when height exceeds limit', async () => {
+		execFileImpl = (cmd, _args, _opts, cb) => {
+			if (cmd === 'vipsheader') cb(null, '4000\n12000\n', '')
+			else if (cmd === 'vipsthumbnail') cb(null, '', '')
+		}
+
+		const resizer = createResizer()
+		const result = await resizer.resize(testJpegPath, 'image/jpeg')
+
+		expect(result.tempFile).toBeDefined()
+		expect(result.path).toEndWith('.jpg')
+		expect(result.mimeType).toBe('image/jpeg')
+	})
+
+	it('converts webp to jpeg on resize', async () => {
+		execFileImpl = (cmd, _args, _opts, cb) => {
+			if (cmd === 'vipsheader') cb(null, '9000\n9000\n', '')
+			else if (cmd === 'vipsthumbnail') cb(null, '', '')
+		}
+
+		const resizer = createResizer()
+		const result = await resizer.resize('/tmp/test.webp', 'image/webp')
+
+		expect(result.path).toEndWith('.jpg')
+		expect(result.mimeType).toBe('image/jpeg')
+	})
+
+	it('converts gif to jpeg on resize', async () => {
+		execFileImpl = (cmd, _args, _opts, cb) => {
+			if (cmd === 'vipsheader') cb(null, '9000\n9000\n', '')
+			else if (cmd === 'vipsthumbnail') cb(null, '', '')
+		}
+
+		const resizer = createResizer()
+		const result = await resizer.resize('/tmp/test.gif', 'image/gif')
+
+		expect(result.path).toEndWith('.jpg')
+		expect(result.mimeType).toBe('image/jpeg')
+	})
+
+	it('converts png to jpeg on resize', async () => {
+		execFileImpl = (cmd, _args, _opts, cb) => {
+			if (cmd === 'vipsheader') cb(null, '9000\n9000\n', '')
+			else if (cmd === 'vipsthumbnail') cb(null, '', '')
+		}
+
+		const resizer = createResizer()
+		const result = await resizer.resize('/tmp/test.png', 'image/png')
+
+		expect(result.path).toEndWith('.jpg')
+		expect(result.mimeType).toBe('image/jpeg')
+	})
+
+	it('returns original path when vipsheader fails (graceful degradation)', async () => {
+		execFileImpl = (_cmd, _args, _opts, cb) => {
+			cb(new Error('vipsheader: command not found'), '', '')
+		}
+
+		const resizer = createResizer()
+		const result = await resizer.resize(testJpegPath, 'image/png')
+
+		expect(result).toEqual({ path: testJpegPath, mimeType: 'image/png' })
+		expect(warnSpy).toHaveBeenCalled()
+	})
+
+	it('returns original path when vipsthumbnail fails (graceful degradation)', async () => {
+		execFileImpl = (cmd, _args, _opts, cb) => {
+			if (cmd === 'vipsheader') cb(null, '10000\n10000\n', '')
+			else if (cmd === 'vipsthumbnail') cb(new Error('vipsthumbnail: command not found'), '', '')
+		}
+
+		const resizer = createResizer()
+		const result = await resizer.resize(testJpegPath, 'image/png')
+
+		expect(result).toEqual({ path: testJpegPath, mimeType: 'image/png' })
+		expect(warnSpy).toHaveBeenCalled()
+	})
+
+	it('returns original path when vipsheader returns unparseable output for jpeg', async () => {
+		execFileImpl = (cmd, _args, _opts, cb) => {
+			if (cmd === 'vipsheader') cb(null, 'not-a-number\n', '')
+		}
+
+		const resizer = createResizer()
+		const result = await resizer.resize(testJpegPath, 'image/jpeg')
+
+		expect(result).toEqual({ path: testJpegPath, mimeType: 'image/jpeg' })
+	})
+
+	it('uses custom maxDimension', async () => {
+		let thumbnailArgs: string[] = []
+		execFileImpl = (cmd, args, _opts, cb) => {
+			if (cmd === 'vipsheader') cb(null, '5000\n5000\n', '')
+			else if (cmd === 'vipsthumbnail') {
+				thumbnailArgs = args
+				cb(null, '', '')
+			}
+		}
+
+		const resizer = createResizer(4000)
+		const result = await resizer.resize(testJpegPath, 'image/jpeg')
+
+		expect(result.tempFile).toBeDefined()
+		expect(thumbnailArgs).toContain('4000x4000')
+	})
+
+	describe('compression (maxFileSizeBytes)', () => {
+		it('skips compression when file fits within limit', async () => {
+			const testPath = '/tmp/test-small.jpg'
+			// Write a small file for size check
+			await Bun.write(testPath, Buffer.alloc(100))
+
+			execFileImpl = (cmd, _args, _opts, cb) => {
+				if (cmd === 'vipsheader') cb(null, '4000\n3000\n', '')
+			}
+
+			const resizer = createResizer()
+			const result = await resizer.resize(testPath, 'image/jpeg', { maxFileSizeBytes: 1000 })
+
+			expect(result).toEqual({ path: testPath, mimeType: 'image/jpeg' })
+
+			await import('node:fs/promises').then(fs => fs.unlink(testPath).catch(() => {}))
+		})
+
+		it('tries compression with quality steps when file exceeds limit', async () => {
+			const testPath = '/tmp/test-large-compress.jpg'
+			await Bun.write(testPath, Buffer.alloc(2000))
+
+			const thumbnailCalls: Array<{ args: string[] }> = []
+
+			execFileImpl = (cmd, args, _opts, cb) => {
+				if (cmd === 'vipsheader') {
+					cb(null, '4000\n3000\n', '')
+				} else if (cmd === 'vipsthumbnail') {
+					thumbnailCalls.push({ args })
+					// Write a small file so it fits on first compression attempt
+					const outputArg = args[args.indexOf('-o') + 1]
+					const outputPath = outputArg.replace(/\[.*\]$/, '')
+					Bun.write(outputPath, Buffer.alloc(50)).then(() => cb(null, '', ''))
+				}
+			}
+
+			const resizer = createResizer()
+			const result = await resizer.resize(testPath, 'image/jpeg', { maxFileSizeBytes: 100 })
+
+			expect(result.mimeType).toBe('image/jpeg')
+			expect(result.tempFile).toBeDefined()
+			expect(thumbnailCalls.length).toBe(1) // First quality step should succeed
+			// Check it used quality parameter
+			const outputArg = thumbnailCalls[0].args[thumbnailCalls[0].args.indexOf('-o') + 1]
+			expect(outputArg).toContain('[Q=85]')
+
+			if (result.tempFile) {
+				await import('node:fs/promises').then(fs => fs.unlink(result.tempFile!).catch(() => {}))
+			}
+			await import('node:fs/promises').then(fs => fs.unlink(testPath).catch(() => {}))
+		})
+
+		it('tries progressively lower quality until file fits', async () => {
+			const testPath = '/tmp/test-progressive.jpg'
+			await Bun.write(testPath, Buffer.alloc(2000))
+
+			let compressionAttempts = 0
+
+			execFileImpl = (cmd, args, _opts, cb) => {
+				if (cmd === 'vipsheader') {
+					cb(null, '4000\n3000\n', '')
+				} else if (cmd === 'vipsthumbnail') {
+					compressionAttempts++
+					const outputArg = args[args.indexOf('-o') + 1]
+					const outputPath = outputArg.replace(/\[.*\]$/, '')
+					// First two attempts produce large files, third fits
+					const size = compressionAttempts <= 2 ? 2000 : 50
+					Bun.write(outputPath, Buffer.alloc(size)).then(() => cb(null, '', ''))
+				}
+			}
+
+			const resizer = createResizer()
+			const result = await resizer.resize(testPath, 'image/jpeg', { maxFileSizeBytes: 100 })
+
+			expect(compressionAttempts).toBe(3) // Q=85, Q=70 failed, Q=50 succeeded
+			expect(result.mimeType).toBe('image/jpeg')
+
+			if (result.tempFile) {
+				await import('node:fs/promises').then(fs => fs.unlink(result.tempFile!).catch(() => {}))
+			}
+			await import('node:fs/promises').then(fs => fs.unlink(testPath).catch(() => {}))
+		})
+
+		it('halves dimensions when quality reduction is insufficient', async () => {
+			const testPath = '/tmp/test-half-dim.jpg'
+			await Bun.write(testPath, Buffer.alloc(2000))
+
+			const dimensionArgs: string[] = []
+			let compressionAttempts = 0
+
+			execFileImpl = (cmd, args, _opts, cb) => {
+				if (cmd === 'vipsheader') {
+					cb(null, '4000\n3000\n', '')
+				} else if (cmd === 'vipsthumbnail') {
+					compressionAttempts++
+					dimensionArgs.push(args[args.indexOf('--size') + 1])
+					const outputArg = args[args.indexOf('-o') + 1]
+					const outputPath = outputArg.replace(/\[.*\]$/, '')
+					// Only the last attempt (halved dimensions, Q=30) fits
+					const size = compressionAttempts < 7 ? 2000 : 50
+					Bun.write(outputPath, Buffer.alloc(size)).then(() => cb(null, '', ''))
+				}
+			}
+
+			const resizer = createResizer()
+			const result = await resizer.resize(testPath, 'image/jpeg', { maxFileSizeBytes: 100 })
+
+			// 4 full-dim attempts + 3 half-dim attempts
+			expect(compressionAttempts).toBe(7)
+			// First 4 at full dimension, last 3 at half
+			expect(dimensionArgs[0]).toBe('8000x8000')
+			expect(dimensionArgs[4]).toBe('4000x4000')
+			expect(result.mimeType).toBe('image/jpeg')
+
+			if (result.tempFile) {
+				await import('node:fs/promises').then(fs => fs.unlink(result.tempFile!).catch(() => {}))
+			}
+			await import('node:fs/promises').then(fs => fs.unlink(testPath).catch(() => {}))
+		})
+
+		it('returns best effort when nothing fits', async () => {
+			const testPath = '/tmp/test-nothing-fits.jpg'
+			await Bun.write(testPath, Buffer.alloc(2000))
+
+			execFileImpl = (cmd, args, _opts, cb) => {
+				if (cmd === 'vipsheader') {
+					cb(null, '4000\n3000\n', '')
+				} else if (cmd === 'vipsthumbnail') {
+					const outputArg = args[args.indexOf('-o') + 1]
+					const outputPath = outputArg.replace(/\[.*\]$/, '')
+					// Always too large
+					Bun.write(outputPath, Buffer.alloc(2000)).then(() => cb(null, '', ''))
+				}
+			}
+
+			const resizer = createResizer()
+			const result = await resizer.resize(testPath, 'image/jpeg', { maxFileSizeBytes: 100 })
+
+			// Returns the last attempt even though it doesn't fit
+			expect(result.mimeType).toBe('image/jpeg')
+			expect(result.tempFile).toBeDefined()
+
+			if (result.tempFile) {
+				await import('node:fs/promises').then(fs => fs.unlink(result.tempFile!).catch(() => {}))
+			}
+			await import('node:fs/promises').then(fs => fs.unlink(testPath).catch(() => {}))
+		})
+
+		it('always outputs jpeg when compressing', async () => {
+			const testPath = '/tmp/test-png-compress.png'
+			await Bun.write(testPath, Buffer.alloc(2000))
+
+			execFileImpl = (cmd, args, _opts, cb) => {
+				if (cmd === 'vipsheader') {
+					cb(null, '4000\n3000\n', '')
+				} else if (cmd === 'vipsthumbnail') {
+					const outputArg = args[args.indexOf('-o') + 1]
+					const outputPath = outputArg.replace(/\[.*\]$/, '')
+					Bun.write(outputPath, Buffer.alloc(50)).then(() => cb(null, '', ''))
+				}
+			}
+
+			const resizer = createResizer()
+			const result = await resizer.resize(testPath, 'image/png', { maxFileSizeBytes: 100 })
+
+			// Even though input was PNG, compression outputs JPEG
+			expect(result.mimeType).toBe('image/jpeg')
+			expect(result.path).toContain('.jpg')
+
+			if (result.tempFile) {
+				await import('node:fs/promises').then(fs => fs.unlink(result.tempFile!).catch(() => {}))
+			}
+			await import('node:fs/promises').then(fs => fs.unlink(testPath).catch(() => {}))
+		})
+	})
+})

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

@@ -0,0 +1,124 @@
+import { join } from 'node:path'
+import type { FileSystem } from '~/platform/fs.js'
+import type { ProcessRunner } from '~/platform/process.js'
+import type { ImageResizeOptions, ImageResizer, ImageResizeResult } from './types.js'
+
+export interface VipsImageResizerOptions {
+	fs: FileSystem
+	process: ProcessRunner
+	tmpDir: string
+	maxDimension?: number
+}
+
+export class VipsImageResizer implements ImageResizer {
+	private readonly fs: FileSystem
+	private readonly process: ProcessRunner
+	private readonly tmpDir: string
+	private readonly maxDimension: number
+
+	constructor(options: VipsImageResizerOptions) {
+		this.fs = options.fs
+		this.process = options.process
+		this.tmpDir = options.tmpDir
+		this.maxDimension = options.maxDimension ?? 8000
+	}
+
+	async resize(filePath: string, mimeType: string, options?: ImageResizeOptions): Promise<ImageResizeResult> {
+		try {
+			// Step 1: Dimension resize if needed
+			const result = await this.dimensionResize(filePath, mimeType)
+
+			// Step 2: If no size constraint, done
+			if (!options?.maxFileSizeBytes) return result
+
+			// Step 3: Check if result fits
+			const fileSize = (await this.fs.stat(result.path)).size
+			if (fileSize <= options.maxFileSizeBytes) return result
+
+			// Step 4: Compress to fit — clean up dimension resize temp first
+			if (result.tempFile) {
+				await this.fs.unlink(result.tempFile).catch(() => {})
+			}
+
+			return await this.compressToFit(filePath, options.maxFileSizeBytes)
+		} catch (e) {
+			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 })
+		const lines = stdout.trim().split('\n')
+		if (lines.length < 2) return null
+		const width = parseInt(lines[0], 10)
+		const height = parseInt(lines[1], 10)
+		if (!Number.isFinite(width) || !Number.isFinite(height)) return null
+		return { width, height }
+	}
+
+	private async dimensionResize(filePath: string, mimeType: string): Promise<ImageResizeResult> {
+		const dims = await this.getImageDimensions(filePath)
+		const needsResize = dims !== null && (dims.width > this.maxDimension || dims.height > this.maxDimension)
+
+		// JPEGs within dimension limits pass through unchanged
+		if (mimeType === 'image/jpeg' && !needsResize) {
+			return { path: filePath, mimeType }
+		}
+
+		// Always convert to JPEG (PNG→JPEG saves significant size for LLM context)
+		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',
+			`${this.maxDimension}x${this.maxDimension}`,
+			'-o',
+			outputPath,
+		], { timeout: 30_000 })
+		return { path: outputPath, mimeType: 'image/jpeg', tempFile: outputPath }
+	}
+
+	private async compressToFit(filePath: string, maxFileSizeBytes: number): Promise<ImageResizeResult> {
+		const halfDim = Math.floor(this.maxDimension / 2)
+		const attempts = [
+			{ dimension: this.maxDimension, quality: 85 },
+			{ dimension: this.maxDimension, quality: 70 },
+			{ dimension: this.maxDimension, quality: 50 },
+			{ dimension: this.maxDimension, quality: 30 },
+			{ dimension: halfDim, quality: 70 },
+			{ dimension: halfDim, quality: 50 },
+			{ dimension: halfDim, quality: 30 },
+		]
+
+		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 })
+
+			// Clean up previous attempt
+			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
+			}
+		}
+
+		// Return best effort (most compressed) — caller decides what to do
+		return lastResult!
+	}
+}

package/src/core/llm/__snapshots__/anthropic-assistant-text-with-tool-calls.json

@@ -0,0 +1,156 @@
+{
+	"requestHash": "89237c5e43937a5c",
+	"request": {
+		"url": "https://api.anthropic.com/v1/messages",
+		"method": "POST",
+		"headers": {
+			"content-type": "application/json",
+			"anthropic-version": "2023-06-01",
+			"anthropic-dangerous-direct-browser-access": "true"
+		},
+		"body": {
+			"model": "claude-haiku-4-5-20251001",
+			"max_tokens": 100000,
+			"system": [
+				{
+					"type": "text",
+					"text": "You have access to tools. When asked about weather, first say you will check, then use the tool.",
+					"cache_control": {
+						"type": "ephemeral"
+					}
+				}
+			],
+			"messages": [
+				{
+					"role": "user",
+					"content": [
+						{
+							"type": "text",
+							"text": "What is the weather in Prague and London?"
+						}
+					]
+				},
+				{
+					"role": "assistant",
+					"content": [
+						{
+							"type": "text",
+							"text": "Let me check the weather for both cities."
+						},
+						{
+							"type": "tool_use",
+							"id": "call_001",
+							"name": "get_weather",
+							"input": {
+								"city": "Prague"
+							}
+						},
+						{
+							"type": "tool_use",
+							"id": "call_002",
+							"name": "get_weather",
+							"input": {
+								"city": "London"
+							}
+						}
+					]
+				},
+				{
+					"role": "user",
+					"content": [
+						{
+							"type": "tool_result",
+							"tool_use_id": "call_001",
+							"content": "Sunny, 22°C"
+						},
+						{
+							"type": "tool_result",
+							"tool_use_id": "call_002",
+							"content": "Rainy, 14°C"
+						}
+					]
+				}
+			],
+			"stream": false,
+			"tools": [
+				{
+					"name": "get_weather",
+					"description": "Get current weather for a city",
+					"input_schema": {
+						"$schema": "https://json-schema.org/draft/2020-12/schema",
+						"type": "object",
+						"properties": {
+							"city": {
+								"type": "string"
+							}
+						},
+						"required": [
+							"city"
+						],
+						"additionalProperties": false
+					}
+				}
+			]
+		}
+	},
+	"response": {
+		"status": 200,
+		"headers": {
+			"anthropic-organization-id": "88f06382-85f0-4a77-882c-b9cb5f669db5",
+			"anthropic-ratelimit-input-tokens-limit": "4000000",
+			"anthropic-ratelimit-input-tokens-remaining": "4000000",
+			"anthropic-ratelimit-input-tokens-reset": "2026-03-19T16:33:46Z",
+			"anthropic-ratelimit-output-tokens-limit": "800000",
+			"anthropic-ratelimit-output-tokens-remaining": "800000",
+			"anthropic-ratelimit-output-tokens-reset": "2026-03-19T16:33:47Z",
+			"anthropic-ratelimit-requests-limit": "4000",
+			"anthropic-ratelimit-requests-remaining": "3999",
+			"anthropic-ratelimit-requests-reset": "2026-03-19T16:33:46Z",
+			"anthropic-ratelimit-tokens-limit": "4800000",
+			"anthropic-ratelimit-tokens-remaining": "4800000",
+			"anthropic-ratelimit-tokens-reset": "2026-03-19T16:33:46Z",
+			"cf-cache-status": "DYNAMIC",
+			"cf-ray": "9dede1761d4af970-PRG",
+			"connection": "keep-alive",
+			"content-encoding": "gzip",
+			"content-security-policy": "default-src 'none'; frame-ancestors 'none'",
+			"content-type": "application/json",
+			"date": "Thu, 19 Mar 2026 16:33:47 GMT",
+			"request-id": "req_011CZCm7wZ3KzvWVnGMH5emF",
+			"server": "cloudflare",
+			"server-timing": "proxy;dur=1039",
+			"strict-transport-security": "max-age=31536000; includeSubDomains; preload",
+			"transfer-encoding": "chunked",
+			"vary": "Accept-Encoding",
+			"x-envoy-upstream-service-time": "1039",
+			"x-robots-tag": "none",
+			"set-cookie": "_cfuvid=iL.nlh8Vh6Jqo0Q2oWK8TDptjCQDnADFxRZi1ZVHEtM-1773938025.9341393-1.0.1.1-bRbOeMXqIGcyvodYFULgQJ81cosE9ptZgazIHtQGKpw; HttpOnly; SameSite=None; Secure; Path=/; Domain=api.anthropic.com"
+		},
+		"body": {
+			"model": "claude-haiku-4-5-20251001",
+			"id": "msg_013tfen48Simz1JEgTcDQ8Mb",
+			"type": "message",
+			"role": "assistant",
+			"content": [
+				{
+					"type": "text",
+					"text": "Here's the weather for both cities:\n\n- **Prague**: Sunny, 22°C\n- **London**: Rainy, 14°C\n\nPrague is enjoying nice sunny weather with pleasant temperatures, while London is experiencing rainy conditions and is a bit cooler."
+				}
+			],
+			"stop_reason": "end_turn",
+			"stop_sequence": null,
+			"usage": {
+				"input_tokens": 795,
+				"cache_creation_input_tokens": 0,
+				"cache_read_input_tokens": 0,
+				"cache_creation": {
+					"ephemeral_5m_input_tokens": 0,
+					"ephemeral_1h_input_tokens": 0
+				},
+				"output_tokens": 61,
+				"service_tier": "standard",
+				"inference_geo": "not_available"
+			}
+		}
+	}
+}