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/llm/llm-deepseek/README.md

@@ -28,12 +28,10 @@ A second, independent implementation of the same seam exists in `@deepseek-ai/ds
 - Streaming only (`stream_options.include_usage` always on). `usage` may arrive attached to the finish chunk or as a trailing usage-only chunk — the translator defers both to `[DONE]`, so `usage` always precedes `finish` and nothing follows `finish`.
 - The first thinking-mode chunk carries `reasoning_content: ""` — handled (no spurious reasoning block).
 - **Reasoning passback rule**: on assistant turns that carried tool calls, `reasoning_content` is serialized back in history (required by the API in thinking mode); on tool-call-free turns it is dropped (ignored anyway — saves tokens).
-- `strict` on tool schemas passes through (officially Beta; the public API wants the `/beta` base URL for it, the internal endpoint accepts it directly).
 - Cache accounting: `cacheReadTokens` ← `prompt_cache_hit_tokens` / `prompt_tokens_details.cached_tokens`; DeepSeek reports no cache-write metric.
 
 ## Limitations (MVP, documented deliberately)
 
-- `prefill` throws `LlmError('UNSUPPORTED')` — DeepSeek's chat-prefix completion is a Beta feature on the `/beta` base URL; future work.
 - `tool_choice` is not mapped (not part of the core vocabulary).
 
 ## Errors

packages/llm/llm-deepseek/src/serialize.ts

@@ -15,7 +15,6 @@
  * @module dsh-llm-deepseek/serialize
  */
 
-import { LlmError } from '@deepseek-ai/dsh-llm'
 import type { ContentBlock, GenerateOptions, Message } from '@deepseek-ai/dsh-llm'
 import type { WireMessage, WireRequest, WireTool } from './types.ts'
 
@@ -98,19 +97,8 @@ export function serializeMessages(messages: Message[]): WireMessage[] {
   return wire
 }
 
-/**
- * Build the full wire request. Throws `LlmError('UNSUPPORTED')` for
- * `prefill` (DeepSeek's chat-prefix completion is a Beta feature on a
- * different base URL — see README).
- */
+/** Build the full wire request. */
 export function serializeRequest(options: GenerateOptions, defaults: RequestDefaults = {}): WireRequest {
-  if (options.prefill !== undefined) {
-    throw new LlmError(
-      'prefill is not supported by the DeepSeek adapter (Beta chat-prefix completion is future work)',
-      'UNSUPPORTED',
-    )
-  }
-
   const messages: WireMessage[] = []
   if (options.system !== undefined) {
     messages.push({ role: 'system', content: options.system })
@@ -123,8 +111,6 @@ export function serializeRequest(options: GenerateOptions, defaults: RequestDefa
       name: tool.name,
       description: tool.description,
       parameters: tool.parameters,
-      // strict is officially supported (Beta); pass the tool author's choice.
-      ...tool.strict !== undefined ? { strict: tool.strict } : {},
     },
   }))
 

packages/llm/llm-deepseek/src/types.ts

@@ -78,8 +78,6 @@ export interface WireTool {
     name: string
     description: string
     parameters: Record<string, unknown>
-    /** Beta: strict schema adherence (official: requires the /beta base URL). */
-    strict?: boolean
   }
 }
 

packages/llm/llm-deepseek/tests/serialize.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { CallId, LlmError } from '@deepseek-ai/dsh-llm'
+import { CallId } from '@deepseek-ai/dsh-llm'
 import type { ContentBlock, GenerateOptions, Message } from '@deepseek-ai/dsh-llm'
 import { serializeMessages, serializeRequest } from '@deepseek-ai/dsh-llm-deepseek'
 
@@ -155,17 +155,17 @@ describe('serializeRequest', () => {
     expect(wire.stop).toEqual(['END'])
   })
 
-  it('maps tools with strict passthrough', () => {
+  it('maps tools to the wire function shape', () => {
     const wire = serializeRequest(request({
       messages: history,
       tools: [
         { name: 'a', description: 'A', parameters: { type: 'object', properties: {} } },
-        { name: 'b', description: 'B', parameters: { type: 'object', properties: {} }, strict: true },
+        { name: 'b', description: 'B', parameters: { type: 'object', properties: { x: { type: 'string' } } } },
       ],
     }))
     expect(wire.tools).toEqual([
       { type: 'function', function: { name: 'a', description: 'A', parameters: { type: 'object', properties: {} } } },
-      { type: 'function', function: { name: 'b', description: 'B', parameters: { type: 'object', properties: {} }, strict: true } },
+      { type: 'function', function: { name: 'b', description: 'B', parameters: { type: 'object', properties: { x: { type: 'string' } } } } },
     ])
   })
 
@@ -185,17 +185,6 @@ describe('serializeRequest', () => {
     expect(wire.thinking).toBeUndefined()
     expect(wire.reasoning_effort).toBeUndefined()
   })
-
-  it('rejects prefill with an UNSUPPORTED LlmError', () => {
-    expect(() => serializeRequest(request({ prefill: [{ type: 'text', text: 'Sure' }] })))
-      .toThrow(LlmError)
-    try {
-      serializeRequest(request({ prefill: [] }))
-      expect.unreachable()
-    } catch (error) {
-      expect((error as LlmError).code).toBe('UNSUPPORTED')
-    }
-  })
 })
 
 describe('review fixes: assistant content shapes', () => {

packages/llm/llm-pi-ai/README.md

@@ -9,7 +9,7 @@ DeepSeek adapter for the harness LLM seam backed by [`@earendil-works/pi-ai`](ht
 - pi-ai hands tool-call `arguments` around as **parsed objects**; the harness keeps raw JSON strings. The adapter patches replay payloads back to the original raw strings before sending them, and re-stringifies parsed output tool calls at `block-end`.
 - pi-ai reports failures as **in-stream error events** (it never throws mid-stream); these map to `finish {kind:'error'|'aborted'}` chunks — the protocol's other sanctioned error path besides throwing (which llm-deepseek uses).
 - pi-ai folds reasoning tokens into `usage.output`; there is no separate reasoning count to map.
-- pi-ai's options omit some DeepSeek/OpenAI-compatible details; the adapter uses its `onPayload` hook to preserve the harness contract (`stop`, per-tool `strict`, omitted reasoning effort, raw replayed tool arguments).
+- pi-ai's options omit some DeepSeek/OpenAI-compatible details; the adapter uses its `onPayload` hook to preserve the harness contract (`stop`, scrubbing pi-ai's own per-tool `strict` default — the hand-rolled twin sends no such field — omitted reasoning effort, raw replayed tool arguments).
 
 ## Config
 
@@ -31,7 +31,7 @@ pi-ai declares the openai/anthropic/google/mistral/AWS SDKs as install-time depe
 
 ## Limitations
 
-Same MVP contract as llm-deepseek: `prefill` throws `UNSUPPORTED`, `tool_choice` is not mapped.
+Same MVP contract as llm-deepseek: `tool_choice` is not mapped.
 
 ## Testing
 

packages/llm/llm-pi-ai/src/adapter.ts

@@ -13,9 +13,9 @@
 
 import { stream as piStream } from '@earendil-works/pi-ai'
 import type { Model } from '@earendil-works/pi-ai'
-import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm'
+import { LlmAdapter } from '@deepseek-ai/dsh-llm'
 import { CallId } from '@deepseek-ai/dsh-llm'
-import type { GenerateOptions, StreamChunk, ToolSchema } from '@deepseek-ai/dsh-llm'
+import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm'
 import { toPiContext, toStreamChunks } from './convert.ts'
 
 /** Reasoning levels surfaced by this adapter (DeepSeek wire: high|max). */
@@ -61,7 +61,7 @@ export function buildModel(modelId: string, options: PiAiAdapterOptions): Model<
 }
 
 type Payload = {
-  tools?: { function?: { name?: unknown; strict?: unknown } }[]
+  tools?: { function?: { strict?: unknown } }[]
   messages?: {
     role?: unknown
     tool_calls?: { id?: unknown; function?: { arguments?: unknown } }[]
@@ -81,10 +81,6 @@ function rawToolArguments(options: GenerateOptions): Map<CallId, string> {
   return raw
 }
 
-function strictByToolName(tools: ToolSchema[] | undefined): Map<string, boolean | undefined> {
-  return new Map((tools ?? []).map(tool => [tool.name, tool.strict]))
-}
-
 function patchPayload(payload: unknown, options: GenerateOptions, reasoning: PiAiReasoning | undefined): unknown {
   /* v8 ignore next -- pi-ai onPayload always receives an object; tolerate unusual future hooks defensively */
   if (typeof payload !== 'object' || payload === null) return payload
@@ -97,16 +93,13 @@ function patchPayload(payload: unknown, options: GenerateOptions, reasoning: PiA
     body.stop = options.stop
   }
 
-  const strictByName = strictByToolName(options.tools)
+  // pi-ai stamps its own `strict` default on every serialized tool; the
+  // harness tool contract has no strict field and the hand-rolled twin sends
+  // none, so scrub it for wire parity.
   for (const tool of body.tools ?? []) {
     /* v8 ignore next -- malformed pi-ai payload guard: real tool entries always carry function */
     if (tool.function === undefined) continue
-    const name = tool.function.name
-    /* v8 ignore next -- malformed pi-ai payload guard: real function entries always carry a string name */
-    if (typeof name !== 'string') continue
-    const strict = strictByName.get(name)
-    if (strict === undefined) delete tool.function.strict
-    else tool.function.strict = strict
+    delete tool.function.strict
   }
 
   const rawById = rawToolArguments(options)
@@ -131,9 +124,9 @@ function patchPayload(payload: unknown, options: GenerateOptions, reasoning: PiA
  *
  * Implementation notes:
  * - `onPayload` patches provider payload details pi-ai cannot express directly:
- *   stop sequences, per-tool strict, omitted reasoning effort, and raw replayed
- *   tool-call arguments.
- * - `prefill` throws UNSUPPORTED (same contract as dsh-llm-deepseek).
+ *   stop sequences, scrubbing pi-ai's own per-tool `strict` default (the
+ *   hand-rolled twin sends no such field), omitted reasoning effort, and raw
+ *   replayed tool-call arguments.
  * - pi-ai reports request failures as in-stream error events; convert.ts
  *   maps them to `finish {kind:'error'|'aborted'}` chunks rather than
  *   throwing — both are sanctioned StreamChunk error paths.
@@ -144,13 +137,6 @@ export class PiAiAdapter extends LlmAdapter {
   }
 
   async * stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
-    if (options.prefill !== undefined) {
-      throw new LlmError(
-        'prefill is not supported by the pi-ai adapter',
-        'UNSUPPORTED',
-      )
-    }
-
     const model = buildModel(options.model, this.options)
     // Undefined config means "provider default" (DeepSeek: thinking ENABLED),
     // matching llm-deepseek's omission semantics. pi-ai derives the wire

packages/llm/llm-pi-ai/tests/adapter.spec.ts

@@ -2,7 +2,7 @@ import { createServer } from 'node:http'
 import type { IncomingMessage, Server, ServerResponse } from 'node:http'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
-import LlmService, { CallId, LlmError } from '@deepseek-ai/dsh-llm'
+import LlmService, { CallId } from '@deepseek-ai/dsh-llm'
 import * as LlmPiAi from '@deepseek-ai/dsh-llm-pi-ai'
 import { buildModel, PiAiAdapter } from '@deepseek-ai/dsh-llm-pi-ai'
 import { assemble } from './assemble.ts'
@@ -149,26 +149,26 @@ describe('PiAiAdapter against a mock server', () => {
     expect(server.requests[0]).toMatchObject({ stop: ['END'] })
   })
 
-  it('preserves per-tool strict exactly through onPayload', async () => {
+  it('scrubs pi-ai\'s own per-tool strict default through onPayload', async () => {
     const server = await mockServer([{ events: textEvents }])
     const ctx = await harness(server.url)
     await assemble(ctx,{
       model: 'deepseek-v4-flash',
       messages: [],
       tools: [
-        { name: 'strict_true', description: 'true', parameters: {}, strict: true },
-        { name: 'strict_false', description: 'false', parameters: {}, strict: false },
-        { name: 'strict_omitted', description: 'omitted', parameters: {} },
+        { name: 'alpha', description: 'a', parameters: {} },
+        { name: 'beta', description: 'b', parameters: {} },
       ],
     })
 
+    // pi-ai stamps `strict` on every serialized tool function; the harness
+    // contract has none and the hand-rolled twin sends no such field, so the
+    // payload fixup must have deleted it from every tool.
     const request = server.requests[0] as { tools: { function: { name: string; strict?: boolean } }[] }
-    expect(request.tools.map(tool => [tool.function.name, tool.function.strict])).toEqual([
-      ['strict_true', true],
-      ['strict_false', false],
-      ['strict_omitted', undefined],
-    ])
-    expect('strict' in request.tools[2]!.function).toBe(false)
+    expect(request.tools.map(tool => tool.function.name)).toEqual(['alpha', 'beta'])
+    for (const tool of request.tools) {
+      expect('strict' in tool.function).toBe(false)
+    }
   })
 
   it('preserves raw replayed tool-call arguments in the provider payload', async () => {
@@ -209,15 +209,6 @@ describe('PiAiAdapter against a mock server', () => {
     expect(result.finish).toMatchObject({ kind: 'error', code })
   })
 
-  it('rejects prefill with UNSUPPORTED', async () => {
-    const ctx = await harness('http://127.0.0.1:1')
-    await expect(assemble(ctx,{
-      model: 'deepseek-v4-flash',
-      messages: [],
-      prefill: [{ type: 'text', text: 'Sure' }],
-    })).rejects.toThrow(LlmError)
-  })
-
   it('registers/unregisters models on the llm service (HMR safety)', async () => {
     const ctx = new Context()
     await ctx.plugin(LlmService)

packages/llm/llm/src/types.ts

@@ -163,7 +163,6 @@ export interface ToolSchema {
   description: string
   /** JSON Schema object for the arguments. */
   parameters: Record<string, unknown>
-  strict?: boolean
 }
 
 /** A single model request, fully assembled. */
@@ -174,8 +173,6 @@ export interface GenerateOptions {
   system?: string
   /** Tool schemas (adapters map to the provider's `tools` field). */
   tools?: ToolSchema[]
-  /** Assistant prefix continuation (prefill). */
-  prefill?: ContentBlock[]
   temperature?: number
   maxTokens?: number
   /**