Tianyi Cui
dc95a7881d
Reshape the agent's interception surface so every seam returns a small, typed
Decision union, and the set covers the hook points a CC/Codex bridge (and a
native plugin) needs. "Native hooks" are not a package — a native hook is just a
cordis plugin on these canonical events; the bridges (a later PR) only translate
an external protocol onto the same surface.
dsh-agent:
- NEW agent/session-start(agent, source) emit (once before turn 1; SessionStartSource
startup|resume|clear|compact) — a pure notification, seeds context via inject().
- NEW agent/prompt-submit waterfall → PromptDecision (allow, optionally rewriting the
prompt or attaching additionalContext, or block).
- RESHAPE agent/turn-continuation boolean → ContinuationDecision ({action:'stop'} |
{action:'continue', reason?}; a continue reason is recorded as next-step steering).
- New HookContext envelope (required source — inject() would mislabel a missing one).
dsh-tools: split the single tools/execute waterfall into tools/pre-execute
(PreToolDecision allow/deny/ask gate) and tools/post-execute (PostToolDecision
accept/block, optionally replacing content or attaching additionalContext). Core
dispatch sits between as plain code; the tool body keeps its inner try/catch so a
thrown tool still reaches post-execute as an isError. ToolExecutionResult gains
additionalContext (ferried to the loop's per-step buffer). Input rewrite is
deliberately NOT offered (a proposed RFC designs it consistently).
dsh-session: new `rejected` TurnEndReason — a turn whose whole prompt batch was
blocked by prompt-submit.
agent-loop firing points: session-start emitted at create (source threaded —
startup for create/fork, resume for resume()); prompt-submit per drained message
with the always-open-turn rule (a fully-blocked batch is a zero-step rejected
turn); the continuation reshape; post-tool additionalContext buffered and appended
after all tool/results (adjacency). ACP codec maps rejected→cancelled.
A worked native-plugin example (interception.spec.ts) proves all four seams compose
end-to-end through the real loop with NO hook/* events (those belong to the bridge
lib). All existing tools/execute + turn-continuation tests migrated. The
tool-subagent abort test now aborts after a microtask so it still exercises the
live onAbort bridge (execute() awaits pre-execute before the body runs).
RFCs: implemented/feature/2026-06-30-interception-seams.md (the reshape) +
proposed/feature/2026-06-30-pre-tool-input-rewrite.md (the deferred rewrite design).
69 lines
3.2 KiB
TypeScript
69 lines
3.2 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import type { TurnEndReason } from '@deepseek-ai/dsh-session'
|
|
import type { ContentBlock as AcpContentBlock } from '@agentclientprotocol/sdk'
|
|
import {
|
|
acpPromptToText,
|
|
harnessBlockToAcpContent,
|
|
promptHasUnsupportedContent,
|
|
turnEndToStopReason,
|
|
} from '../src/codec.ts'
|
|
|
|
describe('turnEndToStopReason', () => {
|
|
// The SDK rejects an unknown stopReason, so this must be total over every
|
|
// TurnEndReason kind and always produce a legal wire value.
|
|
it('maps every known TurnEndReason kind to a legal StopReason', () => {
|
|
expect(turnEndToStopReason({ kind: 'completed' })).toBe('end_turn')
|
|
expect(turnEndToStopReason({ kind: 'max-tokens' })).toBe('max_tokens')
|
|
expect(turnEndToStopReason({ kind: 'aborted', reason: 'x' })).toBe('cancelled')
|
|
expect(turnEndToStopReason({ kind: 'disposed' })).toBe('cancelled')
|
|
expect(turnEndToStopReason({ kind: 'rejected', reason: 'blocked by hook' })).toBe('cancelled')
|
|
expect(turnEndToStopReason({ kind: 'error', step: 1, message: 'boom' })).toBe('end_turn')
|
|
})
|
|
|
|
it('falls back to end_turn for an unknown (merge-extensible) future kind', () => {
|
|
// A plugin-added TurnEndReason variant the bridge does not yet know about
|
|
// must still produce a legal wire value, not throw into the SDK.
|
|
const future = { kind: 'refusal' } as unknown as TurnEndReason
|
|
expect(turnEndToStopReason(future)).toBe('end_turn')
|
|
})
|
|
})
|
|
|
|
describe('harnessBlockToAcpContent', () => {
|
|
it('maps a text block to ACP text content', () => {
|
|
expect(harnessBlockToAcpContent({ type: 'text', text: 'hi' })).toEqual({ type: 'text', text: 'hi' })
|
|
})
|
|
|
|
it('returns undefined for non-text blocks (reasoning/tool/image)', () => {
|
|
expect(harnessBlockToAcpContent({ type: 'reasoning', text: 'think' })).toBeUndefined()
|
|
expect(harnessBlockToAcpContent({ type: 'image', url: 'https://x/y.png', mimeType: 'image/png' })).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('acpPromptToText', () => {
|
|
it('concatenates text blocks and renders resource links explicitly', () => {
|
|
const prompt: AcpContentBlock[] = [
|
|
{ type: 'text', text: 'hello ' },
|
|
{ type: 'resource_link', uri: 'file:///x', name: 'x' },
|
|
{ type: 'text', text: 'world' },
|
|
]
|
|
expect(acpPromptToText(prompt)).toBe('hello \n[resource_link name="x" uri="file:///x"]\nworld')
|
|
})
|
|
|
|
it('returns empty string for a prompt with no text blocks', () => {
|
|
expect(acpPromptToText([{ type: 'image', mimeType: 'image/png', data: 'AA==' }])).toBe('')
|
|
})
|
|
})
|
|
|
|
describe('promptHasUnsupportedContent', () => {
|
|
it('detects image, audio, and embedded resource blocks', () => {
|
|
expect(promptHasUnsupportedContent([{ type: 'image', mimeType: 'image/png', data: 'AA==' }])).toBe(true)
|
|
expect(promptHasUnsupportedContent([{ type: 'audio', mimeType: 'audio/wav', data: 'AA==' }])).toBe(true)
|
|
expect(promptHasUnsupportedContent([{ type: 'resource', resource: { uri: 'file:///x', text: 'x' } }])).toBe(true)
|
|
})
|
|
|
|
it('passes baseline text and resource_link prompt blocks', () => {
|
|
expect(promptHasUnsupportedContent([{ type: 'text', text: 'hi' }])).toBe(false)
|
|
expect(promptHasUnsupportedContent([{ type: 'resource_link', uri: 'file:///x', name: 'x' }])).toBe(false)
|
|
})
|
|
})
|