@empyria/restate 0.1.23 → 0.2.0

package/lib/agent/Skills.js

@@ -0,0 +1,81 @@
+import { createHash } from 'node:crypto'
+import { TerminalError } from '@restatedev/restate-sdk'
+
+export const LOAD_SKILL_TOOL = 'load_skill'
+
+/**
+ * @typedef {{name: string, sha256: string}} SkillRef What the journal records for a loaded
+ *   skill instead of its body.
+ */
+
+/** @param {string} body */
+export const hashSkill = (body) => createHash('sha256').update(body).digest('hex')
+
+/**
+ * The `load_skill` tool result as it's journaled and kept in history: a reference only.
+ * {@link expandSkillRefs} turns it back into the body right before each model call.
+ * @param {SkillRef} skillRef
+ */
+export const skillRefOutput = (skillRef) => ({ type: 'json', value: { skillRef } })
+
+/**
+ * Returns a copy of `messages` with every `load_skill` reference replaced by the skill's
+ * body. Called inside each LLM step's `ctx.run`, whose input is never journaled — so skill
+ * bodies never reach the journal, only the {@link SkillRef}s do.
+ *
+ * `strict` is for references recorded in the current invocation: the body must hash to the
+ * recorded value, otherwise the skill changed between the original execution and a replay,
+ * and the model would silently see different instructions than before — a `TerminalError`.
+ * Non-strict is for references from earlier turns of a session: a skill updated between
+ * turns is legitimate, so the current body is used, or a notice if the skill is gone.
+ * @param {Array<object>} messages
+ * @param {{fetchSkill?: (name: string) => Promise<string|undefined>, strict: boolean}} params
+ * @returns {Promise<Array<object>>}
+ */
+export async function expandSkillRefs(messages, { fetchSkill, strict }) {
+	return Promise.all(
+		messages.map(async (message) => {
+			if (message.role !== 'tool' || !Array.isArray(message.content)) return message
+			return {
+				...message,
+				content: await Promise.all(
+					message.content.map((part) => expandPart(part, { fetchSkill, strict })),
+				),
+			}
+		}),
+	)
+}
+
+async function expandPart(part, { fetchSkill, strict }) {
+	const skillRef = part.type === 'tool-result' && part.output?.value?.skillRef
+	if (part.toolName !== LOAD_SKILL_TOOL || !skillRef) return part
+
+	const body = (await fetchSkill?.(skillRef.name)) ?? undefined
+	if (body !== undefined && (!strict || hashSkill(body) === skillRef.sha256)) {
+		return { ...part, output: { type: 'text', value: body } }
+	}
+	if (strict) {
+		throw new TerminalError(
+			`Skill "${skillRef.name}" changed or disappeared during this invocation; refusing to send the model different instructions than it saw before`,
+		)
+	}
+	return {
+		...part,
+		output: { type: 'error-text', value: `Skill "${skillRef.name}" is no longer available.` },
+	}
+}
+
+/**
+ * Memoises `loadSkill` for one execution of the handler. A replay starts a new execution
+ * and so a fresh cache; the hash check in {@link expandSkillRefs} catches content that
+ * changed in between.
+ * @param {(name: string) => Promise<string|undefined>} [loadSkill]
+ */
+export function cachedSkillFetcher(loadSkill) {
+	if (!loadSkill) return undefined
+	const cache = new Map()
+	return (name) => {
+		if (!cache.has(name)) cache.set(name, Promise.resolve(loadSkill(name)))
+		return cache.get(name)
+	}
+}

package/lib/agent/Tools.js

@@ -0,0 +1,215 @@
+import { tool, jsonSchema } from 'ai'
+import { CancelledError, TerminalError, TimeoutError, serde } from '@restatedev/restate-sdk'
+import { defineSchema, string } from '@empyria/common'
+import { DEFAULT_TOOL_RETRY } from './Errors.js'
+import { LOAD_SKILL_TOOL, hashSkill, skillRefOutput } from './Skills.js'
+
+/**
+ * Tool names the agent loop owns itself; a user-declared tool can't reuse them.
+ */
+export { LOAD_SKILL_TOOL }
+export const FINAL_ANSWER_TOOL = 'final_answer'
+
+const TOOL_NAME = /^[a-zA-Z0-9_-]{1,64}$/
+
+/**
+ * @typedef {Object} ApprovalSpec Human (or system) approval required before a tool runs.
+ * @property {number} timeout Milliseconds to wait for a decision. A timeout counts as a
+ *   rejection.
+ * @property {{block: string|{name: string}, handler: string, key?: string}} notify Handler
+ *   that's sent `{awakeableId, tool, input, invocationId}` when approval is needed. The
+ *   approver answers by resolving the awakeable with `{approved: boolean, reason?: string}`
+ *   (Restate ingress: `POST /restate/awakeables/<awakeableId>/resolve`).
+ *
+ * @typedef {Object} BlockToolSpec A tool executed as a Restate call to another building block.
+ *   Restate journals the call, retries it inside the callee and guarantees it runs once.
+ * @property {string} description
+ * @property {object} inputSchema JSON Schema of the tool's arguments, shown to the model.
+ * @property {string|{name: string}} block Target service/object/workflow, by name or definition.
+ * @property {string} handler Target handler.
+ * @property {(args: any) => string} [key] Virtual object / workflow key, derived from the arguments.
+ * @property {ApprovalSpec} [approval]
+ *
+ * @typedef {Object} ExecuteToolSpec A tool executed as a direct side effect inside its own `ctx.run`.
+ * @property {string} description
+ * @property {object} inputSchema JSON Schema of the tool's arguments, shown to the model.
+ * @property {(args: any, meta: {idempotencyKey: string}) => any} execute Runs the side effect.
+ *   May run more than once before its result is recorded: pass `idempotencyKey` on to the
+ *   external system for any write. Must return a small JSON-serialisable value.
+ * @property {import('@restatedev/restate-sdk').RunOptions<any>} [retry] Defaults to
+ *   {@link DEFAULT_TOOL_RETRY}.
+ * @property {ApprovalSpec} [approval]
+ *
+ * @typedef {BlockToolSpec|ExecuteToolSpec} ToolSpec
+ */
+
+/**
+ * Validates a `tools` map at definition time, so a misconfigured agent fails on startup
+ * rather than on its first invocation.
+ * @param {Record<string, ToolSpec>} tools
+ * @throws {TypeError}
+ */
+export function assertToolSpecs(tools) {
+	for (const [name, spec] of Object.entries(tools)) {
+		if (!TOOL_NAME.test(name)) {
+			throw new TypeError(`Invalid tool name '${name}': use [a-zA-Z0-9_-], at most 64 chars`)
+		}
+		if (name === LOAD_SKILL_TOOL || name === FINAL_ANSWER_TOOL) {
+			throw new TypeError(`Tool name '${name}' is reserved by the agent loop`)
+		}
+		if (typeof spec.description !== 'string' || !spec.inputSchema) {
+			throw new TypeError(`Tool '${name}' needs a description and an inputSchema`)
+		}
+		const isBlock = spec.block !== undefined
+		const isExecute = typeof spec.execute === 'function'
+		if (isBlock === isExecute) {
+			throw new TypeError(`Tool '${name}' needs exactly one of 'block' or 'execute'`)
+		}
+		if (isBlock && typeof spec.handler !== 'string') {
+			throw new TypeError(`Block tool '${name}' needs a 'handler'`)
+		}
+		if (spec.approval) {
+			const { timeout, notify } = spec.approval
+			if (!(timeout > 0) || !notify?.block || !notify?.handler) {
+				throw new TypeError(
+					`Tool '${name}' approval needs a positive 'timeout' and a 'notify' {block, handler}`,
+				)
+			}
+		}
+	}
+}
+
+/**
+ * AI SDK tool definitions for the model. None has an `execute`: AI SDK then returns the
+ * requested call instead of running it, so {@link executeTool} owns every execution as
+ * its own durable step.
+ * @param {{tools: Record<string, ToolSpec>, hasSkills: boolean, outputSchema?: object}} params
+ */
+export function buildToolDefs({ tools, hasSkills, outputSchema }) {
+	const defs = Object.fromEntries(
+		Object.entries(tools).map(([name, spec]) => [
+			name,
+			tool({ description: spec.description, inputSchema: jsonSchema(spec.inputSchema) }),
+		]),
+	)
+	if (hasSkills) {
+		defs[LOAD_SKILL_TOOL] = tool({
+			description:
+				"Load the full instructions for a named skill, by the name shown in the system prompt's skill index.",
+			inputSchema: jsonSchema(defineSchema({ name: string() })),
+		})
+	}
+	if (outputSchema) {
+		defs[FINAL_ANSWER_TOOL] = tool({
+			description: 'Return your final answer. Call this exactly once, when you are done.',
+			inputSchema: jsonSchema(outputSchema),
+		})
+	}
+	return defs
+}
+
+/**
+ * Executes one model-requested tool call and returns the AI SDK tool-result `output`.
+ *
+ * Error policy (see the workflow model, §7): a tool that fails terminally — rejected
+ * approval, a `TerminalError` from the callee, an `execute` tool whose retries ran out —
+ * is reported back to the model as `error-text`, so the agent can adapt. Transient errors
+ * are never swallowed: Restate retries them. Cancellation always propagates.
+ * @param {import('@restatedev/restate-sdk').Context} ctx
+ * @param {{toolCallId: string, toolName: string, input: any}} call
+ * @param {{tools: Record<string, ToolSpec>, loadSkill?: (name: string) => Promise<string|undefined>, step: number, index: number}} params
+ */
+export async function executeTool(ctx, call, { tools, loadSkill, step, index }) {
+	const stepId = `${step}.${index}`
+	try {
+		if (call.toolName === LOAD_SKILL_TOOL && loadSkill) {
+			// Journals only the reference; the body is put back into the conversation inside
+			// each LLM step, never recorded (see Skills.js).
+			const skillRef = await ctx.run(`skill:${call.input?.name}-${stepId}`, async () => {
+				const body = await loadSkill(call.input?.name)
+				return typeof body === 'string'
+					? { name: call.input.name, sha256: hashSkill(body) }
+					: null
+			})
+			return skillRef === null
+				? {
+						type: 'error-text',
+						value: `No skill named "${call.input?.name}" is available.`,
+					}
+				: skillRefOutput(skillRef)
+		}
+
+		const spec = tools[call.toolName]
+		if (!spec) return { type: 'error-text', value: `Unknown tool "${call.toolName}".` }
+
+		if (spec.approval) {
+			const decision = await requestApproval(ctx, call, spec.approval)
+			if (!decision.approved) {
+				return {
+					type: 'error-text',
+					value: `Tool "${call.toolName}" was not approved: ${decision.reason ?? 'rejected'}.`,
+				}
+			}
+		}
+
+		const value = spec.execute
+			? await ctx.run(
+					`tool:${call.toolName}-${stepId}`,
+					async () =>
+						(await spec.execute(call.input, {
+							idempotencyKey: `${ctx.request().id}:${stepId}`,
+						})) ?? null,
+					spec.retry ?? DEFAULT_TOOL_RETRY,
+				)
+			: await ctx.genericCall({
+					service: targetName(spec.block),
+					method: spec.handler,
+					key: spec.key?.(call.input),
+					parameter: call.input,
+					inputSerde: serde.json,
+					outputSerde: serde.json,
+				})
+
+		return { type: 'json', value: value ?? null }
+	} catch (error) {
+		if (error instanceof CancelledError || !(error instanceof TerminalError)) throw error
+		return { type: 'error-text', value: error.message }
+	}
+}
+
+/**
+ * Asks for approval through an awakeable and waits for the decision, durably.
+ * @param {import('@restatedev/restate-sdk').Context} ctx
+ * @param {{toolName: string, input: any}} call
+ * @param {ApprovalSpec} approval
+ * @returns {Promise<{approved: boolean, reason?: string}>}
+ */
+async function requestApproval(ctx, call, { timeout, notify }) {
+	const { id, promise } = ctx.awakeable()
+	ctx.genericSend({
+		service: targetName(notify.block),
+		method: notify.handler,
+		key: notify.key,
+		parameter: {
+			awakeableId: id,
+			tool: call.toolName,
+			input: call.input,
+			invocationId: ctx.request().id,
+		},
+		inputSerde: serde.json,
+	})
+
+	let decision
+	try {
+		decision = await promise.orTimeout(timeout)
+	} catch (error) {
+		if (error instanceof TimeoutError) return { approved: false, reason: 'approval timed out' }
+		throw error
+	}
+	return {
+		approved: decision?.approved === true,
+		reason: typeof decision?.reason === 'string' ? decision.reason : undefined,
+	}
+}
+
+const targetName = (block) => (typeof block === 'string' ? block : block.name)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@empyria/restate",
-	"version": "0.1.23",
+	"version": "0.2.0",
 	"description": "Restate.dev helpers for the Empyria nanoservice framework",
 	"license": "MIT",
 	"author": "Imre Fazekas <imre.fazekas@icloud.com>",
@@ -12,6 +12,7 @@
 	"main": "./index.js",
 	"exports": {
 		".": "./index.js",
+		"./agent": "./agent.js",
 		"./lib/*": "./lib/*.js",
 		"./package.json": "./package.json"
 	},
@@ -34,10 +35,29 @@
 		"croner": "10.0.1"
 	},
 	"devDependencies": {
+		"@ai-sdk/openai-compatible": "3.0.60",
+		"@ai-sdk/provider": "4.0.20",
 		"@restatedev/restate-server": "1.7.12",
+		"ai": "7.0.123",
 		"oxfmt": "0.71.0",
 		"oxlint": "1.86.0"
 	},
+	"peerDependencies": {
+		"@ai-sdk/openai-compatible": "^3.0.60",
+		"@ai-sdk/provider": "^4.0.20",
+		"ai": "^7.0.123"
+	},
+	"peerDependenciesMeta": {
+		"@ai-sdk/openai-compatible": {
+			"optional": true
+		},
+		"@ai-sdk/provider": {
+			"optional": true
+		},
+		"ai": {
+			"optional": true
+		}
+	},
 	"engines": {
 		"bun": ">=1.4.2",
 		"node": ">=26"

package/test/agent/Agent.test.js

@@ -0,0 +1,195 @@
+import { describe, test, expect } from 'bun:test'
+import { MockLanguageModelV4 } from 'ai/test'
+import { TerminalError } from '@restatedev/restate-sdk'
+import { createAgentService, defineAgent } from '../../lib/agent/Agent.js'
+import { DEFAULT_AGENT_RETRY_POLICY } from '../../lib/agent/Errors.js'
+import { env, fakeCtx, sequence, textResult, toolCallResult } from './fakes.js'
+
+const okModel = () => new MockLanguageModelV4({ doGenerate: textResult('ok') })
+
+describe('defineAgent: definition', () => {
+	test('memory none → a service named after the agent, with the default retry policy', () => {
+		const agent = defineAgent({ name: 'Triage', model: okModel() })
+		expect(agent.name).toBe('Triage')
+		expect(typeof agent.service.ask).toBe('function')
+		expect(agent.options.retryPolicy).toEqual(DEFAULT_AGENT_RETRY_POLICY)
+	})
+
+	test('memory session → a virtual object with ask and reset', () => {
+		const agent = defineAgent({ name: 'Chat', model: okModel(), memory: 'session' })
+		expect(Object.keys(agent.object).sort()).toEqual(['ask', 'reset'])
+	})
+
+	test.each([
+		['no name', { model: {} }],
+		['no model or env', { name: 'A' }],
+		['an unknown memory mode', { name: 'A', model: {}, memory: 'forever' }],
+		['a historyStore without session memory', { name: 'A', model: {}, historyStore: {} }],
+		['an invalid tool', { name: 'A', model: {}, tools: { load_skill: {} } }],
+	])('rejects %s', (_, spec) => {
+		expect(() => defineAgent(spec)).toThrow(TypeError)
+	})
+
+	test('builds the model from env when no model is given', () => {
+		expect(() => defineAgent({ name: 'A', env })).not.toThrow()
+	})
+})
+
+describe('defineAgent: ask', () => {
+	test('invalid input is terminal', async () => {
+		const agent = defineAgent({ name: 'A', model: okModel() })
+		await expect(agent.service.ask(fakeCtx(), {})).rejects.toThrow(TerminalError)
+		await expect(
+			agent.service.ask(fakeCtx(), { prompt: 'hi', notAField: true }),
+		).rejects.toThrow(TerminalError)
+	})
+
+	test('sends the caller’s prompt, not a value from loadContext', async () => {
+		const model = new MockLanguageModelV4({ doGenerate: textResult('Sure.') })
+		const agent = defineAgent({
+			name: 'A',
+			model,
+			loadContext: async () => ({ systemPrompt: '', skills: [], prompt: 'HIJACKED' }),
+		})
+
+		expect(await agent.service.ask(fakeCtx(), { prompt: 'REAL PROMPT' })).toEqual({
+			text: 'Sure.',
+			steps: 1,
+		})
+		const sent = JSON.stringify(model.doGenerateCalls[0].prompt)
+		expect(sent).toContain('REAL PROMPT')
+		expect(sent).not.toContain('HIJACKED')
+	})
+
+	test('load-context journals the system prompt and skill index, never skill bodies', async () => {
+		const ctx = fakeCtx()
+		const model = new MockLanguageModelV4({
+			doGenerate: sequence(
+				toolCallResult([{ toolName: 'load_skill', input: { name: 'summarise' } }]),
+				textResult('ok'),
+			),
+		})
+		const agent = defineAgent({
+			name: 'A',
+			model,
+			system: 'Static.',
+			loadContext: async () => ({
+				systemPrompt: 'Be terse.',
+				skills: [{ name: 'summarise', description: 'Summarise', body: 'SECRET BODY' }],
+			}),
+		})
+
+		await agent.service.ask(ctx, { prompt: 'hi' })
+
+		const loadContext = ctx.steps.find((s) => s.name === 'load-context')
+		expect(loadContext.result).toEqual({
+			systemPrompt: 'Be terse.',
+			skills: [{ name: 'summarise', description: 'Summarise' }],
+		})
+		expect(JSON.stringify(model.doGenerateCalls[0].prompt)).toContain('Static.\\n\\nBe terse.')
+		expect(JSON.stringify(model.doGenerateCalls[1].prompt)).toContain('SECRET BODY')
+		expect(JSON.stringify(ctx.steps.map((s) => s.result))).not.toContain('SECRET BODY')
+	})
+
+	test('a custom output schema returns final_answer’s arguments, validated', async () => {
+		const output = {
+			type: 'object',
+			properties: { score: { type: 'number' } },
+			required: ['score'],
+			additionalProperties: false,
+		}
+		const answer = (input) =>
+			defineAgent({
+				name: 'A',
+				output,
+				model: new MockLanguageModelV4({
+					doGenerate: toolCallResult([{ toolName: 'final_answer', input }]),
+				}),
+			}).service.ask(fakeCtx(), { prompt: 'rate' })
+
+		expect(await answer({ score: 7 })).toEqual({ score: 7 })
+		await expect(answer({ score: 'high' })).rejects.toThrow(TerminalError)
+	})
+
+	test('a custom input schema with a prompt builder', async () => {
+		const model = okModel()
+		const agent = defineAgent({
+			name: 'A',
+			model,
+			input: { type: 'object', properties: { isin: { type: 'string' } }, required: ['isin'] },
+			prompt: ({ isin }) => `Triage ${isin}`,
+		})
+		await agent.service.ask(fakeCtx(), { isin: 'CH0012' })
+		expect(JSON.stringify(model.doGenerateCalls[0].prompt)).toContain('Triage CH0012')
+	})
+
+	test('createAgentService keeps the old AgentService shape', async () => {
+		const agent = createAgentService({ env, model: okModel() })
+		expect(agent.name).toBe('AgentService')
+		expect(await agent.service.ask(fakeCtx(), { prompt: 'hi' })).toEqual({
+			text: 'ok',
+			steps: 1,
+		})
+	})
+})
+
+describe('defineAgent: session memory', () => {
+	test('without a store: later turns see earlier ones; reset forgets them', async () => {
+		const model = new MockLanguageModelV4({
+			doGenerate: sequence(textResult('first answer'), textResult('second answer')),
+		})
+		const agent = defineAgent({ name: 'Chat', model, memory: 'session' })
+		const ctx = fakeCtx({ key: 'thread-1' })
+
+		await agent.object.ask(ctx, { prompt: 'first question' })
+		await agent.object.ask(ctx, { prompt: 'second question' })
+
+		const second = JSON.stringify(model.doGenerateCalls[1].prompt)
+		expect(second).toContain('first question')
+		expect(second).toContain('first answer')
+		expect(ctx.state.history).toHaveLength(2)
+
+		await agent.object.reset(ctx)
+		expect(ctx.state.history).toBeUndefined()
+	})
+
+	test('without a store: keeps only the last maxHistoryTurns turns', async () => {
+		const agent = defineAgent({
+			name: 'Chat',
+			model: okModel(),
+			memory: 'session',
+			limits: { maxHistoryTurns: 2 },
+		})
+		const ctx = fakeCtx({ key: 'thread-1' })
+		for (const prompt of ['one', 'two', 'three']) await agent.object.ask(ctx, { prompt })
+
+		expect(ctx.state.history).toHaveLength(2)
+		expect(JSON.stringify(ctx.state.history)).not.toContain('"one"')
+	})
+
+	test('with a store: state and journal hold only the ref', async () => {
+		const snapshots = new Map()
+		const historyStore = {
+			load: async (ref) => snapshots.get(ref),
+			save: async (sessionKey, messages) => {
+				const ref = `${sessionKey}@${snapshots.size + 1}`
+				snapshots.set(ref, messages)
+				return ref
+			},
+		}
+		const model = new MockLanguageModelV4({
+			doGenerate: sequence(textResult('first answer'), textResult('second answer')),
+		})
+		const agent = defineAgent({ name: 'Chat', model, memory: 'session', historyStore })
+		const ctx = fakeCtx({ key: 'thread-1' })
+
+		await agent.object.ask(ctx, { prompt: 'first question' })
+		await agent.object.ask(ctx, { prompt: 'second question' })
+
+		expect(ctx.state).toEqual({ historyRef: 'thread-1@2' })
+		expect(snapshots.get('thread-1@2')).toHaveLength(4)
+		expect(JSON.stringify(model.doGenerateCalls[1].prompt)).toContain('first answer')
+		const journaled = JSON.stringify(ctx.steps.map((s) => s.result))
+		expect(journaled).not.toContain('first question')
+	})
+})

package/test/agent/Errors.test.js

@@ -0,0 +1,66 @@
+import { describe, test, expect } from 'bun:test'
+import { TerminalError, RetryableError } from '@restatedev/restate-sdk'
+import { APICallError } from '@ai-sdk/provider'
+import { toRestateLLMError, DEFAULT_LLM_RETRY } from '../../lib/agent/Errors.js'
+
+function apiError({ statusCode, isRetryable, responseHeaders } = {}) {
+	return new APICallError({
+		message: `request failed with status ${statusCode}`,
+		url: 'https://llm.example/v1/chat/completions',
+		requestBodyValues: {},
+		statusCode,
+		isRetryable,
+		responseHeaders,
+	})
+}
+
+describe('toRestateLLMError', () => {
+	test('non-APICallError errors pass through unchanged (Restate treats them as retryable by default)', () => {
+		const original = new TypeError('fetch failed')
+		expect(toRestateLLMError(original)).toBe(original)
+	})
+
+	test('a non-retryable APICallError (e.g. 401) becomes a TerminalError carrying the status code', () => {
+		const error = apiError({ statusCode: 401, isRetryable: false })
+		const mapped = toRestateLLMError(error)
+
+		expect(mapped).toBeInstanceOf(TerminalError)
+		expect(mapped.message).toBe(error.message)
+		expect(mapped.code).toBe(401)
+	})
+
+	test('a retryable APICallError with no Retry-After header passes through unchanged', () => {
+		const error = apiError({ statusCode: 500, isRetryable: true })
+		expect(toRestateLLMError(error)).toBe(error)
+	})
+
+	test('a retryable APICallError with a Retry-After header becomes a RetryableError honoring it', () => {
+		const error = apiError({
+			statusCode: 429,
+			isRetryable: true,
+			responseHeaders: { 'retry-after': '20' },
+		})
+		const mapped = toRestateLLMError(error)
+
+		expect(mapped).toBeInstanceOf(RetryableError)
+		expect(mapped.retryAfter).toEqual({ seconds: 20 })
+	})
+
+	test('a retryable APICallError with a non-numeric Retry-After header passes through unchanged', () => {
+		// e.g. an HTTP-date form of Retry-After, which this module doesn't attempt to parse —
+		// falling back to ctx.run's own RunOptions backoff is safer than mis-parsing it.
+		const error = apiError({
+			statusCode: 429,
+			isRetryable: true,
+			responseHeaders: { 'retry-after': 'Wed, 21 Oct 2026 07:28:00 GMT' },
+		})
+		expect(toRestateLLMError(error)).toBe(error)
+	})
+})
+
+describe('DEFAULT_LLM_RETRY', () => {
+	test('bounds attempts instead of retrying forever', () => {
+		expect(DEFAULT_LLM_RETRY.maxRetryAttempts).toBeGreaterThan(0)
+		expect(Number.isFinite(DEFAULT_LLM_RETRY.maxRetryAttempts)).toBe(true)
+	})
+})