refactor(llm): drop the inert request knobs — prefill and strict

GenerateOptions.prefill had no production setter and both adapters
rejected it with LlmError('UNSUPPORTED') — its entire observable
behavior was two throws, each pinned by one adapter test. DeepSeek's
chat-prefix completion is a Beta feature on a base URL neither adapter
targets. ToolSchema.strict was threaded through defineTool, the
registry's schemas() allowlist, the deepseek wire mapping, a per-tool
payload-patching pass in the pi-ai adapter, and a tool-catalog render
row, yet no shipped tool set it and the internal endpoint story for
strict mode was never built.

Remove both fields end-to-end: the vocabulary in dsh-llm, the adapter
guards and wire branches, the dsh-tools threading, the tool-catalog
Strict row, the pinning tests, the core.md pastes, the adapter README
rows, and the cookbook line that used prefill as the UNSUPPORTED
example (now stated generically). The pi-ai payload fixup keeps the
half with a job: pi-ai stamps strict:false on every serialized tool,
so the fixup scrubs it unconditionally for wire parity with the
hand-rolled twin (per-tool set/delete machinery gone). temperature/
stop/maxTokens are untouched — honored end-to-end by both adapters.

Each knob returns with its first real producer: prefill with an
adapter that implements chat-prefix completion, strict with a tool
that wants it and a beta-endpoint story.

RFC: docs/rfc/implemented/simplification/2026-07-04-drop-inert-request-knobs.md
(moved from proposed/, amended to shipped reality); the content-block
vocabulary RFC's consequence line now records prefill as producer-gated.

packages/core/tools/src/index.ts

@@ -306,20 +306,19 @@ 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.
    */
   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' },