fix(agent): preserve thrown error values

packages/core/agent-loop/tests/coverage-edges.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
-import LlmService, { CallId, LlmError, StreamChunk } from '@deepseek-ai/dsh-llm'
+import LlmService, { CallId, LlmError, StreamChunk, errorChain } from '@deepseek-ai/dsh-llm'
 import SessionStore, { SessionId, TurnEndReason } from '@deepseek-ai/dsh-session'
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
 import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
@@ -131,8 +131,8 @@ describe('tool JSON parse', () => {
   })
 })
 
-describe('toError normalization', () => {
-  it('normalizes non-Error throws from pre-commit dispatch validation via the runLoop backstop', async () => {
+describe('thrown-value propagation', () => {
+  it('preserves non-Error throws from pre-commit dispatch validation', async () => {
     const adapter = new MockAdapter([textResponse('ok')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
@@ -143,57 +143,56 @@ describe('toError normalization', () => {
       const event = args[1] as SessionEvent
       if (event.type === 'turn/start' && !threwOnce) {
         threwOnce = true
-        throw 'naked string error' // non-Error throw, normalized via toError
+        throw 'naked string error'
       }
     })
 
-    const errors: Error[] = []
+    const errors: unknown[] = []
     ctx.on('agent/error', (_agent, _turn, _step, error) => void errors.push(error))
 
     send(agent, 'fails before turn start')
     send(agent, 'survives as the next item')
     await waitForIdle(ctx, agent)
     expect(errors).toHaveLength(1)
-    expect(errors[0]).toMatchObject({ message: 'naked string error', code: 'UNKNOWN' })
+    expect(errors[0]).toBe('naked string error')
     expect(adapter.requests).toHaveLength(1)
     const starts = agent.session.events.filter(event => event.type === 'turn/start')
     const ends = agent.session.events.filter(event => event.type === 'turn/end')
     const messages = agent.session.events.filter(event => event.type === 'user/message')
     expect(starts).toHaveLength(1)
-    expect(starts[0]?.type === 'turn/start' && starts[0].data.turn).toBe(1)
+    expect(starts[0]?.type === 'turn/start' && starts[0].data.turn).toBe(2)
     expect(ends).toHaveLength(1)
-    expect(messages).toHaveLength(1)
-    expect(messages[0]?.type === 'user/message' && messages[0].data.content).toEqual([
+    expect(messages).toHaveLength(2)
+    expect(messages[1]?.type === 'user/message' && messages[1].data.content).toEqual([
       { type: 'text', text: 'survives as the next item' },
     ])
   })
 
-  it('normalizes non-Error throws from agent/request waterfall via inline toError in runStep catch', async () => {
+  it('preserves non-Error throws from the agent/request waterfall', async () => {
     const adapter = new MockAdapter([textResponse('irrelevant')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     let threwOnce = false
-    ctx.on('agent/request', async (_agent, _turn, _step, _options, _signal, _next) => {
+    ctx.on('agent/request', async (_agent, _turn, _step, _signal, next) => {
       if (!threwOnce) {
         threwOnce = true
-        throw { code: 500 } // non-Error throw, goes through runStep catch
+        throw { code: 500 }
       }
-      return _next()
+      return next()
     })
 
-    const errors: Error[] = []
+    const errors: unknown[] = []
     ctx.on('agent/error', (_agent, _turn, _step, error) => void errors.push(error))
 
     send(agent, 'go')
     await waitForIdle(ctx, agent)
     expect(errors).toHaveLength(1)
-    // String() of { code: 500 } is '[object Object]'
-    expect(errors[0]!.message).toBe('[object Object]')
+    expect(errors[0]).toEqual({ code: 500 })
     const turnEnd = agent.session.events.find(e => e.type === 'turn/end')
     expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason.kind === 'error'
       && ('failure' in turnEnd.data.reason ? turnEnd.data.reason.failure.code : turnEnd.data.reason.code))
-      .toBe('UNKNOWN')
+      .toBeUndefined()
   })
 })
 
@@ -204,7 +203,7 @@ describe('coded error data emission', () => {
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     let threwOnce = false
-    ctx.on('agent/request', async (_agent, _turn, _step, _options, _signal, next) => {
+    ctx.on('agent/request', async (_agent, _turn, _step, _signal, next) => {
       if (!threwOnce) {
         threwOnce = true
         throw new LlmError('server overloaded', 'RATE_LIMIT')
@@ -212,13 +211,13 @@ describe('coded error data emission', () => {
       return next()
     })
 
-    const errors: Error[] = []
+    const errors: unknown[] = []
     ctx.on('agent/error', (_agent, _turn, _step, error) => void errors.push(error))
 
     send(agent, 'go')
     await waitForIdle(ctx, agent)
     expect(errors).toHaveLength(1)
-    expect(errors[0]!.message).toBe('server overloaded')
+    expect(errorChain(errors[0])).toBe('server overloaded')
 
     // turn-end error reason includes the code
     const turnEnd = agent.session.events.find(e => e.type === 'turn/end')