|
|
@@ -0,0 +1,197 @@
|
|
|
+/**
|
|
|
+ * Host-side slash-command dispatch in sessions.prompt: a leading-/
|
|
|
+ * single-text-block prompt executes through the command registry and never
|
|
|
+ * reaches the model — symmetric with the ACP adapter. Successful commands
|
|
|
+ * return ok with the command slot; usage errors and unknown names return RPC
|
|
|
+ * errors so the client restores the composer's draft. Non-command prompts
|
|
|
+ * still route to agent.send/steer.
|
|
|
+ */
|
|
|
+
|
|
|
+import { describe, expect, it } from 'vitest'
|
|
|
+import { Context } from 'cordis'
|
|
|
+import AgentRegistry from '@deepseek-ai/dsh-agent'
|
|
|
+import type { Agent, AgentStatus, InjectOptions } from '@deepseek-ai/dsh-agent'
|
|
|
+import CommandService from '@deepseek-ai/dsh-commands'
|
|
|
+import GoalService from '@deepseek-ai/dsh-goal'
|
|
|
+import * as commandGoal from '@deepseek-ai/dsh-command-goal'
|
|
|
+import type { ContentBlock, MessageSource } from '@deepseek-ai/dsh-llm'
|
|
|
+import { Session, SessionId } from '@deepseek-ai/dsh-session'
|
|
|
+import type { RpcRequest } from '@deepseek-ai/dsh-host-apiproxy/api/rpc'
|
|
|
+import { RpcId } from '@deepseek-ai/dsh-host-apiproxy/api/rpc'
|
|
|
+import { createApiProxy } from '../src/api-proxy.ts'
|
|
|
+
|
|
|
+interface Harness {
|
|
|
+ readonly ctx: Context
|
|
|
+ readonly agent: Agent
|
|
|
+ readonly session: Session
|
|
|
+ /** Content arguments of every agent.send/steer call, in order. */
|
|
|
+ readonly sent: ContentBlock[][]
|
|
|
+ readonly steered: ContentBlock[][]
|
|
|
+}
|
|
|
+
|
|
|
+/** Number the next balanced injection turn. */
|
|
|
+function nextTurn(session: Session): number {
|
|
|
+ return session.events.reduce(
|
|
|
+ (maximum, event) => event.type === 'turn/start' ? Math.max(maximum, event.data.turn) : maximum,
|
|
|
+ 0,
|
|
|
+ ) + 1
|
|
|
+}
|
|
|
+
|
|
|
+/** Build a live idle agent whose send/steer calls are recorded. */
|
|
|
+function stubAgent(id: string): { agent: Agent; session: Session; sent: ContentBlock[][]; steered: ContentBlock[][] } {
|
|
|
+ const session = new Session(SessionId(id))
|
|
|
+ const sent: ContentBlock[][] = []
|
|
|
+ const steered: ContentBlock[][] = []
|
|
|
+ let status: AgentStatus = 'idle'
|
|
|
+ const agent: Agent = {
|
|
|
+ id: session.id,
|
|
|
+ options: {},
|
|
|
+ session,
|
|
|
+ ctx: new Context(),
|
|
|
+ get status() { return status },
|
|
|
+ send(content) { sent.push(content) },
|
|
|
+ steer(content) { steered.push(content) },
|
|
|
+ inject(content: ContentBlock[], options?: InjectOptions) {
|
|
|
+ const source: MessageSource = options?.source ?? { kind: 'user' }
|
|
|
+ const turn = nextTurn(session)
|
|
|
+ session.append('turn/start', { turn, trigger: { kind: 'injection', source } })
|
|
|
+ session.append('context/message', {
|
|
|
+ content,
|
|
|
+ source,
|
|
|
+ ...options?.meta === undefined ? {} : { meta: options.meta },
|
|
|
+ }, { surfaceOp: 'append' })
|
|
|
+ session.append('turn/end', { turn, reason: { kind: 'completed' } })
|
|
|
+ },
|
|
|
+ cancel() { status = 'idle' },
|
|
|
+ whenIdle() { return Promise.resolve() },
|
|
|
+ }
|
|
|
+ return { agent, session, sent, steered }
|
|
|
+}
|
|
|
+
|
|
|
+/** Mount the real command registry, goal domain, and /goal producer. */
|
|
|
+async function harness(): Promise<Harness> {
|
|
|
+ const ctx = new Context()
|
|
|
+ await ctx.plugin(CommandService)
|
|
|
+ await ctx.plugin(AgentRegistry)
|
|
|
+ await ctx.plugin(GoalService)
|
|
|
+ await ctx.plugin(commandGoal)
|
|
|
+ const { agent, session, sent, steered } = stubAgent(`api-proxy-command-${Math.random()}`)
|
|
|
+ ctx.agents.register(agent)
|
|
|
+ return { ctx, agent, session, sent, steered }
|
|
|
+}
|
|
|
+
|
|
|
+let nextRpc = 1
|
|
|
+function request<P>(payload: P): RpcRequest<P> {
|
|
|
+ return { rpcId: RpcId(`command-${String(nextRpc++)}`), payload }
|
|
|
+}
|
|
|
+
|
|
|
+function promptPayload(test: Harness, text: string, mode: 'queue' | 'steer' = 'queue') {
|
|
|
+ const content: ContentBlock[] = [{ type: 'text', text }]
|
|
|
+ return request({ sessionId: test.session.id, mode, content })
|
|
|
+}
|
|
|
+
|
|
|
+describe('sessions.prompt slash-command dispatch', () => {
|
|
|
+ it('executes /goal <objective>: goal created, command slot carried, no model turn', async () => {
|
|
|
+ const test = await harness()
|
|
|
+ const api = createApiProxy(test.ctx, { provider: 'p', model: 'm', cwd: '/tmp' })
|
|
|
+
|
|
|
+ const response = await api.sessions.prompt(promptPayload(test, '/goal fix the flaky test'))
|
|
|
+ expect(response.result.ok).toBe(true)
|
|
|
+ if (!response.result.ok) throw new Error('unreachable')
|
|
|
+ expect(response.result.value.accepted).toBe(true)
|
|
|
+ expect(response.result.value.command?.kind).toBe('success')
|
|
|
+ expect(response.result.value.command?.text).toContain('Goal created')
|
|
|
+
|
|
|
+ const goal = test.ctx.goals.get(test.agent)
|
|
|
+ expect(goal?.objective).toBe('fix the flaky test')
|
|
|
+ // The prompt never reached the model: no send, no user/message event.
|
|
|
+ expect(test.sent).toEqual([])
|
|
|
+ expect(test.steered).toEqual([])
|
|
|
+ expect(test.session.events.filter(event => event.type === 'user/message')).toEqual([])
|
|
|
+ })
|
|
|
+
|
|
|
+ it('dispatches commands regardless of mode (steer prompt never steers)', async () => {
|
|
|
+ const test = await harness()
|
|
|
+ const api = createApiProxy(test.ctx, { provider: 'p', model: 'm', cwd: '/tmp' })
|
|
|
+
|
|
|
+ const response = await api.sessions.prompt(promptPayload(test, '/goal', 'steer'))
|
|
|
+ expect(response.result.ok).toBe(true)
|
|
|
+ if (!response.result.ok) throw new Error('unreachable')
|
|
|
+ expect(response.result.value.command?.text).toContain('No goal is currently set')
|
|
|
+ expect(test.sent).toEqual([])
|
|
|
+ expect(test.steered).toEqual([])
|
|
|
+ })
|
|
|
+
|
|
|
+ it('returns unknown-command for an unregistered name', async () => {
|
|
|
+ const test = await harness()
|
|
|
+ const api = createApiProxy(test.ctx, { provider: 'p', model: 'm', cwd: '/tmp' })
|
|
|
+
|
|
|
+ const response = await api.sessions.prompt(promptPayload(test, '/bogus do something'))
|
|
|
+ expect(response.result.ok).toBe(false)
|
|
|
+ if (response.result.ok) throw new Error('unreachable')
|
|
|
+ expect(response.result.error.code).toBe('unknown-command')
|
|
|
+ expect(response.result.error.message).toBe('unknown command: /bogus')
|
|
|
+ expect(test.sent).toEqual([])
|
|
|
+
|
|
|
+ const bare = await api.sessions.prompt(promptPayload(test, '/bogus'))
|
|
|
+ expect(bare.result.ok).toBe(false)
|
|
|
+ if (!bare.result.ok) expect(bare.result.error.message).toBe('unknown command: /bogus')
|
|
|
+ })
|
|
|
+
|
|
|
+ it('carries a success without text when the command produced none', async () => {
|
|
|
+ const test = await harness()
|
|
|
+ const api = createApiProxy(test.ctx, { provider: 'p', model: 'm', cwd: '/tmp' })
|
|
|
+ test.ctx.commands.register({ name: 'ping', description: 'test no-text success', handler: () => ({ kind: 'success' }) })
|
|
|
+
|
|
|
+ const response = await api.sessions.prompt(promptPayload(test, '/ping'))
|
|
|
+ expect(response.result.ok).toBe(true)
|
|
|
+ if (!response.result.ok) throw new Error('unreachable')
|
|
|
+ expect(response.result.value.command).toEqual({ kind: 'success' })
|
|
|
+ expect(test.sent).toEqual([])
|
|
|
+ })
|
|
|
+
|
|
|
+ it('returns command-error for a usage error (bare /goal edit)', async () => {
|
|
|
+ const test = await harness()
|
|
|
+ const api = createApiProxy(test.ctx, { provider: 'p', model: 'm', cwd: '/tmp' })
|
|
|
+
|
|
|
+ const response = await api.sessions.prompt(promptPayload(test, '/goal edit'))
|
|
|
+ expect(response.result.ok).toBe(false)
|
|
|
+ if (response.result.ok) throw new Error('unreachable')
|
|
|
+ expect(response.result.error.code).toBe('command-error')
|
|
|
+ expect(response.result.error.message).toContain('Goal editing requires a replacement objective')
|
|
|
+ expect(test.sent).toEqual([])
|
|
|
+ })
|
|
|
+
|
|
|
+ it('routes a non-command prompt to agent.send unchanged', async () => {
|
|
|
+ const test = await harness()
|
|
|
+ const api = createApiProxy(test.ctx, { provider: 'p', model: 'm', cwd: '/tmp' })
|
|
|
+
|
|
|
+ const response = await api.sessions.prompt(promptPayload(test, 'hello there'))
|
|
|
+ expect(response.result.ok).toBe(true)
|
|
|
+ if (!response.result.ok) throw new Error('unreachable')
|
|
|
+ expect(response.result.value.accepted).toBe(true)
|
|
|
+ expect('command' in response.result.value).toBe(false)
|
|
|
+ expect(test.sent).toEqual([[{ type: 'text', text: 'hello there' }]])
|
|
|
+ })
|
|
|
+
|
|
|
+ it('routes multi-block content starting with / to the model (never flattened)', async () => {
|
|
|
+ const test = await harness()
|
|
|
+ const api = createApiProxy(test.ctx, { provider: 'p', model: 'm', cwd: '/tmp' })
|
|
|
+
|
|
|
+ const content: ContentBlock[] = [{ type: 'text', text: '/goal not a command' }, { type: 'text', text: 'second' }]
|
|
|
+ const response = await api.sessions.prompt(request({ sessionId: test.session.id, mode: 'queue' as const, content }))
|
|
|
+ expect(response.result.ok).toBe(true)
|
|
|
+ expect(test.sent).toEqual([content])
|
|
|
+ })
|
|
|
+
|
|
|
+ it('routes degenerate content shapes to the model (empty array, single non-text block)', async () => {
|
|
|
+ const test = await harness()
|
|
|
+ const api = createApiProxy(test.ctx, { provider: 'p', model: 'm', cwd: '/tmp' })
|
|
|
+
|
|
|
+ const empty: ContentBlock[] = []
|
|
|
+ await api.sessions.prompt(request({ sessionId: test.session.id, mode: 'queue' as const, content: empty }))
|
|
|
+ const nonText: ContentBlock[] = [{ type: 'reasoning', text: '/goal not a command' }]
|
|
|
+ await api.sessions.prompt(request({ sessionId: test.session.id, mode: 'queue' as const, content: nonText }))
|
|
|
+ expect(test.sent).toEqual([empty, nonText])
|
|
|
+ })
|
|
|
+})
|
_Kerman