Merge remote-tracking branch 'origin/master' into persistence-log-catalog

packages/core/agent-loop/src/loop.ts

@@ -166,7 +166,7 @@ export interface LoopHandle {
  *                                                        → dispatch → tools/post-execute
  *         session('tool/result')
  *       append buffered post-execute additionalContext → session('context/message')(s)
- *       drain steering → session('steering/message'); emit agent/steering
+ *       drain steering → session('steering/message')
  *       session('step/end')                           ⟵ durable step boundary (no agent/* mirror)
  *       cont = waterfall agent/turn-continuation       ⟵ ContinuationDecision; default
  *         {action: hadToolCalls||steered ? 'continue':'stop'}; a continue.reason is
@@ -420,7 +420,7 @@ async function runTurn(ctx: Context, agent: ReactLoopAgent, handle: LoopHandle,
 
       // Steering from the previous round's continuation listeners joins before
       // the request.
-      drainSteering(ctx, agent, turn)
+      drainSteering(agent, turn)
 
       // The step's AbortController exists BEFORE any async pre-step work so a
       // dispose() or cancel() — in a synchronous turn-start listener or an
@@ -529,7 +529,7 @@ async function runTurn(ctx: Context, agent: ReactLoopAgent, handle: LoopHandle,
       if (stepReason) reason = stepReason
 
       // Steering that arrived during streaming/tool execution.
-      const steered = drainSteering(ctx, agent, turn)
+      const steered = drainSteering(agent, turn)
 
       if (closeStep()) break
 
@@ -635,11 +635,10 @@ async function runTurn(ctx: Context, agent: ReactLoopAgent, handle: LoopHandle,
 }
 
 /** Drain the steering queue into the session. Returns whether any arrived. */
-function drainSteering(ctx: Context, agent: ReactLoopAgent, turn: number): boolean {
+function drainSteering(agent: ReactLoopAgent, turn: number): boolean {
   const messages = agent.inbox.drainSteering()
   for (const message of messages) {
     agent.session.append('steering/message', { turn, content: message.content, source: message.source }, { surfaceOp: 'append' })
-    ctx.emit('agent/steering', agent, turn, message.content, message.source)
   }
   return messages.length > 0
 }

packages/core/agent-loop/tests/review-fixes.spec.ts

@@ -410,7 +410,7 @@ describe('MEDIUM: misc registry and config fixes', () => {
     expect(agent.session.deriveMessages().at(-1)?.content).toEqual([{ type: 'text', text: 'routed' }])
   })
 
-  it('agent/queued carries the resolved source; agent/steering carries its source', async () => {
+  it('agent/queued carries the resolved source; steering/message records its source', async () => {
     const adapter = new MockAdapter([toolCallResponse('c1', 'noop', {}), textResponse('done')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(AgentId('a1'), { model: 'mock' })
@@ -425,15 +425,16 @@ describe('MEDIUM: misc registry and config fixes', () => {
     }))
 
     const queuedSources: { source: MessageSource; steering: boolean }[] = []
-    const steeringSources: MessageSource[] = []
     ctx.on('agent/queued', (_agent, _content, info) => void queuedSources.push(info))
-    ctx.on('agent/steering', (_agent, _turn, _content, source) => void steeringSources.push(source))
 
     send(agent, 'go') // no explicit source → default {kind:'user'} must be visible
     await waitForIdle(ctx, agent)
 
     expect(queuedSources[0]).toEqual({ source: { kind: 'user' }, steering: false })
     expect(queuedSources[1]).toEqual({ source: { kind: 'plugin', plugin: 'goal' }, steering: true })
+    // The drain appends the durable steering/message with the caller's source
+    // intact — the log, not a transient emit, is where consumers read it.
+    const steeringSources = agent.session.events.flatMap(e => e.type === 'steering/message' ? [e.data.source] : [])
     expect(steeringSources).toEqual([{ kind: 'plugin', plugin: 'goal' }])
   })
 })

packages/core/agent/README.md

@@ -50,9 +50,8 @@ Turn and step boundaries are NOT mirrored as `agent/*` emits: a consumer that ne
 
 Tool interception is the `tools/pre-execute` / `tools/post-execute` pair in [`dsh-tools`](../tools/README.md) (`PreToolDecision` allow/deny/ask, `PostToolDecision` accept/block) — same typed-Decision idiom, owned there because it is the tool registry's seam.
 
-#### Live control notifications (emit)
+#### Error notifications (emit)
 
-- `agent/steering` — steering content injected mid-turn
 - `agent/error` — step/turn error
 
 The model's token stream is NOT an `agent/*` event: read it off the durable `session/event` feed as `assistant/chunk` (the same feed persistence and the ACP bridge use).

packages/core/agent/src/types.ts

@@ -20,7 +20,7 @@
  *   `agent/request`/`agent/step-result`/`agent/turn-continuation` waterfalls and
  *   the serial `agent/pre-step`) that mutate/veto, and TRANSIENT emits
  *   (`agent/status`, `agent/error`, `agent/created`/
- *   `agent/disposed`, `agent/queued`, `agent/steering`, `agent/session-start`)
+ *   `agent/disposed`, `agent/queued`, `agent/session-start`)
  *   that notify with the `Agent` in hand. Turn/step boundaries are NOT here —
  *   they are durable `session/event` records. Answers "right now, with the agent
  *   object — intercept or observe."
@@ -367,16 +367,7 @@ declare module 'cordis' {
      */
     'agent/turn-continuation'(agent: Agent, turn: number, defaultDecision: ContinuationDecision, next: () => Promise<ContinuationDecision>): Promise<ContinuationDecision>
 
-    // ---- streaming + tool notifications (emit) ----
-    /**
-     * Steering content was injected into a running turn.
-     * @param agent - the agent that absorbed the steering.
-     * @param turn - the running turn that received it.
-     * @param content - the injected blocks.
-     * @param source - the steering message's resolved source.
-     * @mode emit
-     */
-    'agent/steering'(agent: Agent, turn: number, content: ContentBlock[], source: MessageSource): void
+    // ---- error notifications (emit) ----
     /**
      * A step or turn errored. The loop reports a failure here (plus the logger)
      * even when the error has no in-turn position for a session `error` event.

packages/core/session/src/types.ts

@@ -91,7 +91,6 @@ export interface CreateSessionOptions {
  */
 export interface TurnTriggerMap {
   message: { kind: 'message'; source: MessageSource }
-  continuation: { kind: 'continuation' }
   /**
    * An out-of-band context injection (`agent.inject()`) made while the agent
    * was idle. The loop wraps the injected `context/message` in a one-shot turn

packages/core/tools/src/index.ts

@@ -317,21 +317,20 @@ export class ToolRegistry extends Service {
 
   /**
    * Return all registered tool schemas — exactly the model-facing fields
-   * (`name`, `description`, `parameters`, and `strict` when set), as sent to the
-   * model via the system-prompt assembly. Constructed EXPLICITLY rather than by
-   * stripping known non-schema members: a `ToolDefinition` also carries
-   * `execute` and the optional `presentCall`/`presentResult` UI callbacks, and
-   * those (especially the functions) must never leak into a model request. An
-   * allowlist can't drift when a new non-schema member is added to the
-   * definition; a denylist (rest-destructure) would silently leak it.
+   * (`name`, `description`, `parameters`), as sent to the model via the
+   * system-prompt assembly. Constructed EXPLICITLY rather than by stripping
+   * known non-schema members: a `ToolDefinition` also carries `execute` and the
+   * optional `presentCall`/`presentResult` UI callbacks, and those (especially
+   * the functions) must never leak into a model request. An allowlist can't
+   * drift when a new non-schema member is added to the definition; a denylist
+   * (rest-destructure) would silently leak it.
    * @returns one deep-cloned schema per registered tool, in registration order.
    */
   schemas(): ToolSchema[] {
-    return [...this.store.values()].map(({ name, description, parameters, strict }): ToolSchema => ({
+    return [...this.store.values()].map(({ name, description, parameters }): ToolSchema => ({
       name,
       description,
       parameters: structuredClone(parameters),
-      ...strict !== undefined ? { strict } : {},
     }))
   }
 

packages/core/tools/src/schema.ts

@@ -312,8 +312,6 @@ export interface DefineToolOptions<S extends SchemaSpec> {
    * free for the same replay reason. See {@link ToolResultView}.
    */
   presentResult?(args: InferArgs<S>, result: ToolResult): ToolResultView | undefined
-  /** Whether the tool requires structured output (default false). */
-  strict?: boolean
 }
 
 /**
@@ -355,7 +353,6 @@ export function defineTool<S extends SchemaSpec>(options: DefineToolOptions<S>):
     name: options.name,
     description: options.description,
     parameters: schemaSpecToJsonSchema(options.parameters) as unknown as Record<string, unknown>,
-    ...options.strict !== undefined ? { strict: options.strict } : {},
     async execute(args: unknown, exec: ToolExecution): Promise<ToolExecuteReturn> {
       // Validate the model-generated args before the typed body runs. On
       // mismatch we throw ToolArgsError; the registry turns it into an

packages/core/tools/tests/gen-tool-catalog.spec.ts

@@ -103,15 +103,4 @@ describe('gen-tool-catalog render', () => {
     expect(md).toContain('```json')
     expect(md).toContain('Source: [`packages/demo/tool-demo/src/index.ts`]')
   })
-
-  it('renders the strict flag when a schema sets it', () => {
-    const catalog: ToolCatalog = [
-      {
-        pkg: '@deepseek-ai/dsh-tool-demo',
-        source: 'packages/demo/tool-demo/src/index.ts',
-        schemas: [{ name: 'demo', description: '', parameters: { type: 'object', properties: {} }, strict: true }],
-      },
-    ]
-    expect(render(catalog)).toContain('Strict: `true`')
-  })
 })

packages/core/tools/tests/tools.spec.ts

@@ -62,18 +62,6 @@ describe('ToolRegistry', () => {
     expect(schema.execute).toBeUndefined()
   })
 
-  it('schemas() preserves `strict` when set (allowlist keeps the model-facing fields)', async () => {
-    const ctx = await setup()
-    ctx.tools.register(defineTool({
-      name: 'strict-tool',
-      description: 'd',
-      parameters: { x: { type: 'string', required: true } },
-      strict: true,
-      async execute() { return [] },
-    }))
-    expect(ctx.tools.schemas()[0]).toMatchObject({ name: 'strict-tool', strict: true })
-  })
-
   it('executes a tool and returns its content', async () => {
     const ctx = await setup()
     ctx.tools.register(echoTool)
@@ -611,44 +599,6 @@ describe('schema DSL edge cases', () => {
     })
   })
 
-  it('defineTool passes through strict flag when set to true', () => {
-    const tool = defineTool({
-      name: 'strict-tool',
-      description: 'A strict tool',
-      parameters: { input: { type: 'string' } },
-      strict: true,
-      async execute(args) {
-        return [{ type: 'text' as const, text: args.input ?? '' }]
-      },
-    })
-    expect(tool.strict).toBe(true)
-  })
-
-  it('defineTool omits strict when not provided', () => {
-    const tool = defineTool({
-      name: 'non-strict-tool',
-      description: 'A non-strict tool',
-      parameters: { input: { type: 'string' } },
-      async execute(args) {
-        return [{ type: 'text' as const, text: args.input ?? '' }]
-      },
-    })
-    expect('strict' in tool).toBe(false)
-  })
-
-  it('defineTool strict=false is included', () => {
-    const tool = defineTool({
-      name: 'explicitly-non-strict',
-      description: 'Explicitly non-strict',
-      parameters: { input: { type: 'string' } },
-      strict: false,
-      async execute(args) {
-        return [{ type: 'text' as const, text: args.input ?? '' }]
-      },
-    })
-    expect(tool.strict).toBe(false)
-  })
-
   it('handles enum and default together in one property', () => {
     const spec = {
       level: { type: 'string', enum: ['low', 'high'], default: 'low' },