@sparkelf/dsh-plus 0.2.1-rc.2.2 → 0.2.2-alpha.2.1

package/patches/llm-pi-ai-transport-truncation.patch

@@ -0,0 +1,33 @@
+diff --git a/packages/llm/llm-pi-ai/src/stream.ts b/packages/llm/llm-pi-ai/src/stream.ts
+index 30e9c79..0e4df53 100644
+--- a/packages/llm/llm-pi-ai/src/stream.ts
++++ b/packages/llm/llm-pi-ai/src/stream.ts
+@@ -56,6 +56,12 @@ function classifyPiAiError(message: string): string {
+   // finish_reason`). The connection dropped mid-response, so this is a transport
+   // truncation, not a model-level error.
+   if (/stream ended (?:before|without)\b/i.test(message)) return 'TRANSPORT'
++  // A gateway in front of the provider relays the same condition in its own words:
++  // the upstream response stream was interrupted, cut short, or dropped. Measured
++  // 2026-10-13 against a d1api route through sub2api: the message reached the model
++  // as an unclassified PI_AI_ERROR, which the default retry set excludes, so a
++  // truncated response ended the turn instead of being retried.
++  if (/upstream response stream|response stream (?:was )?(?:interrupted|aborted|closed|dropped)/i.test(message)) return 'TRANSPORT'
+   if (/\b(?:network|connection|socket|fetch)\b|\bECONN[A-Z]+\b/i.test(message)
+     || /\b(?:other side closed|HTTP2 request did not get a response|WebSocket closed unexpectedly)\b/i.test(message)
+     // undici renders a mid-stream socket drop as a bare `terminated` (its
+diff --git a/packages/llm/llm-pi-ai/tests/convert.spec.ts b/packages/llm/llm-pi-ai/tests/convert.spec.ts
+index d6c86ba..0e57a35 100644
+--- a/packages/llm/llm-pi-ai/tests/convert.spec.ts
++++ b/packages/llm/llm-pi-ai/tests/convert.spec.ts
+@@ -951,6 +951,11 @@ describe('mapStopReason / mapUsage', () => {
+     'OpenAI Responses stream ended before a terminal response event',
+     'openrouter stream ended without a terminal event',
+     'Stream ended without finish_reason',
++    // A gateway relay in front of the provider reports the same truncation in its own
++    // words. Measured 2026-10-13: this wording reached the model as an unclassified
++    // PI_AI_ERROR, which the default retry set excludes, so a truncated response
++    // ended the turn instead of being retried.
++    'Upstream response stream was interrupted',
+   ])('maps pi-ai transport wording %j', (errorMessage) => {
+     expect(mapStopReason(assistant({ stopReason: 'error', errorMessage })))
+       .toMatchObject({ kind: 'error', failure: { code: 'TRANSPORT' } })

package/patches/mobile-journal-generation.patch

@@ -0,0 +1,76 @@
+diff --git a/packages/api/gateway/src/client/journal-stream.ts b/packages/api/gateway/src/client/journal-stream.ts
+index ab013abdf3..35dcb86255 100644
+--- a/packages/api/gateway/src/client/journal-stream.ts
++++ b/packages/api/gateway/src/client/journal-stream.ts
+@@ -241,6 +241,10 @@ export abstract class RemoteJournalStream<
+         if (next.done) return
+         const item = next.value
+         if (item.generation !== this.generation) {
++          // A replaced carrier can surface buffered live entries before its
++          // opening snapshot. The snapshot subsumes them, so retain the
++          // published window and wait for that generation's opening cursor.
++          if (item.value.type !== 'opened') continue
+           this.replaceGeneration(item, true)
+           continue
+         }
+diff --git a/packages/api/gateway/tests/journal-stream.client.spec.ts b/packages/api/gateway/tests/journal-stream.client.spec.ts
+index 498f5a033b..e6f1b41f69 100644
+--- a/packages/api/gateway/tests/journal-stream.client.spec.ts
++++ b/packages/api/gateway/tests/journal-stream.client.spec.ts
+@@ -788,7 +788,7 @@ describe('RemoteJournalStream', () => {
+     await fixture.journal.dispose()
+   })
+ 
+-  it('reports a resumed generation that emits an entry before its cursor', async () => {
++  it('drops resumed entries before the replacement opening cursor', async () => {
+     const finish = Promise.withResolvers<undefined>()
+     const fixture = journalFixture(
+       [
+@@ -797,13 +797,46 @@ describe('RemoteJournalStream', () => {
+           waitAfterFrames: finish.promise,
+           terminal: new RemoteStreamCarrierError('lost'),
+         },
+-        { frames: [{ type: 'entry', entry: { seq: 1 } }] },
++        {
++          frames: [
++            { type: 'entry', entry: { seq: 1 } },
++            opened(1, page('replacement', [0, 1])),
++          ],
++          hold: true,
++        },
+       ],
+       [],
+     )
+ 
+     await fixture.journal.open({})
+     finish.resolve(undefined)
++    await vi.waitFor(() => { expect(fixture.changes).toHaveLength(2) })
++    expect(fixture.changes.at(-1)).toMatchObject({
++      type: 'replace',
++      page: { marker: 'replacement' },
++      entries: [{ seq: 0 }, { seq: 1 }],
++    })
++    expect(fixture.failed).not.toHaveBeenCalled()
++    await fixture.journal.dispose()
++  })
++
++  it('rejects a superseded repair whose replacement emits an entry first', async () => {
++    const gap = Promise.withResolvers<ScriptedFrame>()
++    const fixture = journalFixture(
++      [
++        {
++          frames: [opened(1, page('initial', [0, 1])), gap.promise],
++          terminal: new RemoteStreamCarrierError('generation lost'),
++        },
++        { frames: [{ type: 'entry', entry: { seq: 4 } }], hold: true },
++      ],
++      [
++        () => new Promise<Page>(() => {}),
++      ],
++    )
++
++    await fixture.journal.open({ limit: 5 })
++    gap.resolve({ type: 'entry', entry: { seq: 4 } })
+     await vi.waitFor(() => { expect(fixture.failed).toHaveBeenCalledOnce() })
+     expect(fixture.failed.mock.calls[0]?.[0]).toMatchObject({
+       message: 'resumed fixture journal emitted an entry before its opening cursor',

package/patches/office-preview-stable-load.patch

@@ -0,0 +1,34 @@
+diff --git a/packages/client/ui-sidebar-documentpreview/src/client/office/OfficeBody.tsx b/packages/client/ui-sidebar-documentpreview/src/client/office/OfficeBody.tsx
+index 5d74774e45..f3ef39a610 100644
+--- a/packages/client/ui-sidebar-documentpreview/src/client/office/OfficeBody.tsx
++++ b/packages/client/ui-sidebar-documentpreview/src/client/office/OfficeBody.tsx
+@@ -1,5 +1,5 @@
+ /** Office presents retained conversion results and font notices around the shared PDF view. */
+-import { useEffect, type ReactNode } from 'react'
++import { useEffect, useRef, type ReactNode } from 'react'
+ import type { PropsLocale, PropsRenderSlots, PropsStore, SlotHookFactory } from '@deepseek-ai/dsh-client-ui-slots'
+ import type { TabId } from '@deepseek-ai/dsh-client-ui-dockkit'
+ import { Button, FileTypeIcon, classifyFileType } from '@deepseek-ai/dsh-client-ui-primitives'
+@@ -49,15 +49,19 @@ export function OfficeBody(props: OfficeBodyProps): ReactNode {
+   const held = props.useStore(state => state.byTab[tab.id])
+   const view = held?.revision === revision ? held : undefined
+   const settled = view?.file !== undefined || view?.failure !== undefined
++  /** Newest load callbacks; the effect below reads the ref so a new identity cannot restart it. */
++  const loadRef = useRef(load)
+   useEffect(() => { retainTab(tab.id, tab.signal) }, [retainTab, tab.id, tab.signal])
+-  // Metadata may replace callbacks without advancing the content revision.
++  // Metadata may replace callbacks without advancing the content revision, and the office face
++  // rebuilds them on every render, so this effect reads the ref instead of depending on `load`.
+   useEffect(() => {
+     if (request === undefined || settled || tab.signal.aborted) return
+     const controller = new AbortController()
+     const signal = AbortSignal.any([controller.signal, tab.signal])
+-    load(tab.id, request.revision, hostFileOf(resourceAddress), signal, request.loaded, request.failed)
++    loadRef.current = load
++    loadRef.current(tab.id, request.revision, hostFileOf(resourceAddress), signal, request.loaded, request.failed)
+     return () => { controller.abort() }
+-  }, [revision, resourceAddress, tab.id, tab.signal, load, settled])
++  }, [revision, resourceAddress, tab.id, tab.signal, settled])
+   const file = view?.file
+   if (request === undefined) return null
+   if (view?.failure !== undefined) {

package/patches/officecli-deliverables.patch

@@ -0,0 +1,42 @@
+diff --git a/packages/client/ui-deliverables/src/client/turn-deliverables.ts b/packages/client/ui-deliverables/src/client/turn-deliverables.ts
+index 7eb765ec2b..806d9e4466 100644
+--- a/packages/client/ui-deliverables/src/client/turn-deliverables.ts
++++ b/packages/client/ui-deliverables/src/client/turn-deliverables.ts
+@@ -70,11 +70,37 @@ function mutationPath(name: string, argsRaw: string): string | null {
+       return validEditArgs(args) ? pathValue(args.file_path) : null
+     case 'str_replace_editor':
+       return editorMutationPath(args)
++    case 'officecli':
++      return officeCliMutationPath(args)
+     default:
+       return null
+   }
+ }
+ 
++/** OfficeCLI argv operations that write the original file named by their second item. */
++const OFFICECLI_MUTATIONS = new Set([
++  'create',
++  'set',
++  'add',
++  'remove',
++  'move',
++  'swap',
++  'batch',
++  'refresh',
++  'merge',
++  'raw-set',
++  'add-part',
++  'save',
++  'close',
++])
++
++/** Read the original OfficeCLI argv item that names the file a write operation targets. */
++function officeCliMutationPath(args: Readonly<Record<string, unknown>>): string | null {
++  if (!Array.isArray(args.command) || !args.command.every(value => typeof value === 'string')) return null
++  const [operation, file] = args.command
++  return operation !== undefined && OFFICECLI_MUTATIONS.has(operation) ? pathValue(file) : null
++}
++
+ /** Validate the fields that an `edit` execution requires. */
+ function validEditArgs(args: Readonly<Record<string, unknown>>): boolean {
+   return typeof args.old_string === 'string'

package/patches/ptc-mcp-schema-types.patch

@@ -0,0 +1,156 @@
+diff --git a/packages/core/tool-executor-ptc/src/ts-types.ts b/packages/core/tool-executor-ptc/src/ts-types.ts
+index 8026c847d2..4c0f622fc9 100644
+--- a/packages/core/tool-executor-ptc/src/ts-types.ts
++++ b/packages/core/tool-executor-ptc/src/ts-types.ts
+@@ -8,7 +8,7 @@
+ 
+ import type { ToolSchema } from '@deepseek-ai/dsh-llm'
+ import type { PtcProgramFormat } from '@deepseek-ai/dsh-ptc-runtime'
+-import { assertSupportedJsonSchema } from '@deepseek-ai/dsh-tools'
++import { assertTypeProjectableJsonSchema } from '@deepseek-ai/dsh-tools'
+ import type { JsonSchemaNode, JsonSchemaScalar } from '@deepseek-ai/dsh-tools'
+ /** Internal PTC mode projection: the model-facing schema plus the canonical output schema. */
+ export interface ToolSdkSchema extends Readonly<ToolSchema> {
+@@ -220,7 +220,7 @@ function renderSupportedSchema(schema: JsonSchemaNode, indent: number): TypeDocu
+         }
+         break
+       }
+-      /* v8 ignore next -- assertSupportedJsonSchema narrowed this closed type union. */
++      /* v8 ignore next -- assertTypeProjectableJsonSchema narrowed this closed type union. */
+       default:
+         finish(typeDocument('unknown'))
+     }
+@@ -240,7 +240,7 @@ function renderSupportedSchema(schema: JsonSchemaNode, indent: number): TypeDocu
+  */
+ export function jsonSchemaToTs(schema: unknown, indent = 0): string {
+   try {
+-    assertSupportedJsonSchema(schema)
++    assertTypeProjectableJsonSchema(schema)
+     return flattenTypeDocument(renderSupportedSchema(schema, indent))
+   } catch {
+     return 'unknown'
+diff --git a/packages/core/tool-executor-ptc/tests/ts-types.spec.ts b/packages/core/tool-executor-ptc/tests/ts-types.spec.ts
+index 2ec79e974c..a345818f06 100644
+--- a/packages/core/tool-executor-ptc/tests/ts-types.spec.ts
++++ b/packages/core/tool-executor-ptc/tests/ts-types.spec.ts
+@@ -1,6 +1,7 @@
+ import { describe, expect, it } from 'vitest'
+ import { jsonSchemaToTs, renderToolsSdk } from '@deepseek-ai/dsh-tool-executor-ptc/src/ts-types.ts'
+ import type { ToolSdkSchema } from '@deepseek-ai/dsh-tool-executor-ptc/src/ts-types.ts'
++import { assertSupportedJsonSchema } from '@deepseek-ai/dsh-tools/src/json-schema.ts'
+ import type { JsonSchemaNode } from '@deepseek-ai/dsh-tools/src/json-schema.ts'
+ import { parameterSchemaSpecToJsonSchema } from '@deepseek-ai/dsh-tools'
+ 
+@@ -61,6 +62,47 @@ describe('jsonSchemaToTs', () => {
+     ].join('\n'))
+   })
+ 
++  it('projects MCP validation keywords without admitting them to runtime schema enforcement', () => {
++    const schema = {
++      $schema: 'http://json-schema.org/draft-07/schema#',
++      type: 'object',
++      properties: {
++        sources: {
++          type: 'array',
++          minItems: 1,
++          maxItems: 12,
++          items: {
++            type: 'object',
++            properties: {
++              resourceRef: { type: 'string', minLength: 1, maxLength: 1000 },
++              alias: { type: 'string', pattern: '^[A-Za-z_][A-Za-z0-9_]{0,63}$' },
++            },
++            required: ['resourceRef', 'alias'],
++          },
++        },
++        sql: { type: 'string', minLength: 1, maxLength: 20000 },
++      },
++      required: ['sources', 'sql'],
++    }
++
++    expect(() => { assertSupportedJsonSchema(schema) }).toThrow(/not a supported keyword/)
++    const rendered = jsonSchemaToTs(schema)
++    expect(rendered).toContain('sources:')
++    expect(rendered).toContain('resourceRef: string;')
++    expect(rendered).toContain('alias: string;')
++    expect(rendered).toContain('sql: string;')
++    expect(rendered).not.toBe('unknown')
++    const sdk = renderToolsSdk([{
++      name: 'mcp__dataops__execute_sql',
++      description: 'Execute SQL.',
++      parameters: schema,
++      output: {},
++    }])
++    expect(sdk).toContain('mcp__dataops__execute_sql: {')
++    expect(sdk).not.toContain('mcp__dataops__execute_sql: unknown;')
++    expect(jsonSchemaToTs({ type: 'object', allOf: [{ type: 'object' }] })).toBe('unknown')
++  })
++
+   it('is total: unsupported or hostile constructs degrade to unknown, never throw', () => {
+     const cases: unknown[] = [
+       undefined,
+diff --git a/packages/core/tools/src/json-schema.ts b/packages/core/tools/src/json-schema.ts
+index c064fb294c..573cdd69c0 100644
+--- a/packages/core/tools/src/json-schema.ts
++++ b/packages/core/tools/src/json-schema.ts
+@@ -84,6 +84,14 @@ const CONSTRAINT_KEYWORDS = new Set([
+   'const',
+ ])
+ const ANNOTATION_KEYWORDS = new Set(['description', 'title', 'default', 'examples'])
++const TYPE_PROJECTION_IGNORED_KEYWORDS = new Set([
++  '$schema',
++  'minLength',
++  'maxLength',
++  'pattern',
++  'minItems',
++  'maxItems',
++])
+ const SCHEMA_TYPES: readonly JsonSchemaType[] = ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null']
+ 
+ /* jscpd:ignore-start -- this realm boundary mirrors the session-owned lossless-JSON intrinsic test */
+@@ -224,7 +232,13 @@ function checkObjectSchemaTail(
+ }
+ 
+ /** Collect every violation for one raw schema tree without using the JavaScript call stack. */
+-function checkSchemaNode(root: unknown, rootPath: string, violations: string[], seen: Set<object>): void {
++function checkSchemaNode(
++  root: unknown,
++  rootPath: string,
++  violations: string[],
++  seen: Set<object>,
++  ignoredKeywords?: ReadonlySet<string>,
++): void {
+   const tasks: SchemaWalkTask[] = [{ kind: 'enter', node: root, path: rootPath }]
+   for (let task = tasks.pop(); task !== undefined; task = tasks.pop()) {
+     if (task.kind === 'leave') {
+@@ -256,6 +270,7 @@ function checkSchemaNode(root: unknown, rootPath: string, violations: string[],
+ 
+     for (const key of Object.keys(node)) {
+       if (CONSTRAINT_KEYWORDS.has(key)) continue
++      if (ignoredKeywords?.has(key)) continue
+       if (ANNOTATION_KEYWORDS.has(key)) {
+         try {
+           if (!isJsonValue(node[key])) violations.push(`${path}.${key} annotation must be lossless JSON data`)
+@@ -388,6 +403,22 @@ export function assertSupportedJsonSchema(schema: unknown): asserts schema is Js
+   if (violations.length > 0) throw new JsonSchemaError(violations)
+ }
+ 
++/**
++ * Assert the JSON Schema structure that a generated TypeScript declaration can represent.
++ *
++ * Validation-only string and array constraints remain outside the enforced ToolRuntime
++ * subset. The PTC declaration omits those constraints while retaining their object,
++ * array, property, required, and scalar types. Structural keywords outside the shared
++ * vocabulary still reject the projection.
++ * @param schema - untrusted raw JSON Schema from a registered tool.
++ * @returns Assertion that the schema structure is safe to render as TypeScript.
++ */
++export function assertTypeProjectableJsonSchema(schema: unknown): asserts schema is JsonSchemaNode {
++  const violations: string[] = []
++  checkSchemaNode(schema, 'schema', violations, new Set(), TYPE_PROJECTION_IGNORED_KEYWORDS)
++  if (violations.length > 0) throw new JsonSchemaError(violations)
++}
++
+ /**
+  * Assert the enforced subset plus the object-root constraint retained by
+  * subagent and workflow structured outputs.

package/patches/responses-reasoning-status.patch

@@ -0,0 +1,289 @@
+diff --git a/packages/client/ui-settings-models/src/client/ModelsSection.module.css b/packages/client/ui-settings-models/src/client/ModelsSection.module.css
+index 51995fc1ae..5c2f3a098b 100644
+--- a/packages/client/ui-settings-models/src/client/ModelsSection.module.css
++++ b/packages/client/ui-settings-models/src/client/ModelsSection.module.css
+@@ -463,6 +463,31 @@
+   padding-top: 12px;
+ }
+ 
++.settingToggle {
++  display: flex;
++  align-items: center;
++  gap: 8px;
++  min-height: 32px;
++  width: fit-content;
++  color: var(--dsw-alias-label-primary);
++  font-size: 12px;
++  line-height: 18px;
++  cursor: pointer;
++}
++
++.settingCheckbox {
++  flex: none;
++  width: 16px;
++  height: 16px;
++  margin: 0;
++  accent-color: var(--dsw-alias-state-business-primary);
++  cursor: pointer;
++}
++
++.settingCheckbox:disabled {
++  cursor: not-allowed;
++}
++
+ .modelCatalog {
+   position: relative;
+   display: flex;
+diff --git a/packages/client/ui-settings-models/src/client/ProviderEditor.tsx b/packages/client/ui-settings-models/src/client/ProviderEditor.tsx
+index 262f8c9d55..c1789d7813 100644
+--- a/packages/client/ui-settings-models/src/client/ProviderEditor.tsx
++++ b/packages/client/ui-settings-models/src/client/ProviderEditor.tsx
+@@ -48,6 +48,9 @@ type EditorLayout = 'deepseek' | 'pi-ai' | 'unknown'
+ 
+ 
+ 
++/** Leaf path of the curated OpenAI Responses compatibility setting. */
++const OMIT_REASONING_INPUT_STATUS_PATH = ['responsesCompatibility', 'omitReasoningInputStatus'] as const
++
+ /** Props of {@link ProviderEditor}. */
+ export interface ProviderEditorProps {
+   /** Provider route id. */
+@@ -195,6 +198,10 @@ export function ProviderEditor(props: ProviderEditorProps): ReactNode {
+   const root = useMemo(() => schema.rehydrate(namespace.schema), [namespace.schema, schema])
+   const node = useMemo(() => schema.nodeAtPath(root, settingsPath), [root, schema, settingsPath])
+   const fallback = schema.getPath(namespace.value, settingsPath)
++  const inheritedOmitReasoningInputStatus = schema.getPath(
++    namespace.base,
++    [...settingsPath, ...OMIT_REASONING_INPUT_STATUS_PATH],
++  ) === true
+   const disabled = props.readOnly || busy
+   const layout = layoutOf(namespace.ns)
+   const keyRef = refFor(schema, namespace, settingsPath, props.provider)
+@@ -211,6 +218,11 @@ export function ProviderEditor(props: ProviderEditorProps): ReactNode {
+     const value = schema.getPath(source, [key])
+     return typeof value === 'string' && value.trim().length > 0 ? value : undefined
+   }
++  const disableOmitReasoningInputStatus = (current: Record<string, unknown>): Record<string, unknown> => {
++    return inheritedOmitReasoningInputStatus
++      ? schema.setPath(current, OMIT_REASONING_INPUT_STATUS_PATH, false)
++      : schema.deletePath(current, OMIT_REASONING_INPUT_STATUS_PATH)
++  }
+   const setField = (key: string, next: string | undefined): void => {
+     // A value of nothing but whitespace is cleared, not stored: `stringAt`
+     // already reports it as absent, so the field would otherwise render empty
+@@ -249,6 +261,9 @@ export function ProviderEditor(props: ProviderEditorProps): ReactNode {
+   // What the form currently shows, which is what an interrogation must ask:
+   // an edited-but-unsaved endpoint, and a key typed but not yet stored.
+   const probeApi = stringAt(draft, 'api') ?? stringAt(fallback, 'api')
++  const omitReasoningInputStatus = schema.hasPath(draft, OMIT_REASONING_INPUT_STATUS_PATH)
++    ? schema.getPath(draft, OMIT_REASONING_INPUT_STATUS_PATH) === true
++    : schema.getPath(fallback, OMIT_REASONING_INPUT_STATUS_PATH) === true
+   const probeBaseURL = stringAt(draft, 'baseURL') ?? stringAt(fallback, 'baseURL')
+   const probe = {
+     settingsNs: namespace.ns,
+@@ -497,7 +512,15 @@ export function ProviderEditor(props: ProviderEditorProps): ReactNode {
+                     value={probeApi ?? ''}
+                     aria-label={t('customApi')}
+                     disabled={disabled}
+-                    onChange={(event) => { setField('api', event.target.value) }}
++                    onChange={(event) => {
++                      const selectedApi = event.target.value
++                      setDraft((current) => {
++                        const next = schema.setPath(current, ['api'], selectedApi)
++                        return selectedApi === 'openai-responses'
++                          ? next
++                          : disableOmitReasoningInputStatus(next)
++                      })
++                    }}
+                   >
+                     {/* A profile naming no protocol — hand-written into
+                         cordis.patch.yml with no model to need one — selects
+@@ -511,6 +534,24 @@ export function ProviderEditor(props: ProviderEditorProps): ReactNode {
+                 </div>
+               )
+               : null}
++            {family === 'pi-ai' && probeApi === 'openai-responses'
++              ? (
++                <label className={styles['settingToggle']}>
++                  <input
++                    className={styles['settingCheckbox']}
++                    type="checkbox"
++                    checked={omitReasoningInputStatus}
++                    disabled={disabled}
++                    onChange={(event) => {
++                      setDraft(current => event.target.checked
++                        ? schema.setPath(current, OMIT_REASONING_INPUT_STATUS_PATH, true)
++                        : disableOmitReasoningInputStatus(current))
++                    }}
++                  />
++                  <span>{t('omitReasoningInputStatus')}</span>
++                </label>
++              )
++              : null}
+             {/* Both families edit the same rows through the same contract; only
+                 the extras differ — DeepSeek's inherited capacities, pi-ai's
+                 endpoint interrogation. */}
+diff --git a/packages/client/ui-settings-models/src/client/locales.ts b/packages/client/ui-settings-models/src/client/locales.ts
+index 533b7aed02..35270a4904 100644
+--- a/packages/client/ui-settings-models/src/client/locales.ts
++++ b/packages/client/ui-settings-models/src/client/locales.ts
+@@ -121,6 +121,7 @@ export const en = {
+   protocolOpenAiCompletions: 'OpenAI Chat Completions',
+   protocolOpenAiResponses: 'OpenAI Responses',
+   protocolAnthropicMessages: 'Anthropic Messages',
++  omitReasoningInputStatus: 'Gateway compatibility mode',
+   customNeedsBaseUrl: 'A custom provider needs a base URL.',
+   customBaseUrlInvalid: 'Enter a valid HTTP or HTTPS URL.',
+   customNeedsModels: 'A custom provider needs at least one model.',
+@@ -265,7 +266,8 @@ export const zh: { [Key in keyof typeof en]: string } = {
+   protocolOpenAiCompletions: 'OpenAI Chat Completions',
+   protocolOpenAiResponses: 'OpenAI Responses',
+   protocolAnthropicMessages: 'Anthropic Messages',
+-  customNeedsBaseUrl: '自定义模型 API 需要填写 API 地址。',
++  omitReasoningInputStatus: '中转站兼容模式',
++  customNeedsBaseUrl: '自定义提供方需要填写 API 地址。',
+   customBaseUrlInvalid: '请输入有效的 HTTP 或 HTTPS 地址。',
+   customNeedsModels: '自定义模型 API 至少需要一个模型。',
+   customBaseUrlPlaceholder: 'https://gateway.example/v1',
+@@ -406,6 +408,7 @@ export const ja = {
+   'protocolOpenAiCompletions': 'OpenAI Chat Completions',
+   'protocolOpenAiResponses': 'OpenAI Responses',
+   'protocolAnthropicMessages': 'Anthropic Messages',
++  'omitReasoningInputStatus': 'ゲートウェイ互換モード',
+   'customNeedsBaseUrl': 'カスタムプロバイダーにはベースURLが必要です。',
+   'customBaseUrlInvalid': '有効なHTTPまたはHTTPSのURLを入力してください。',
+   'customNeedsModels': 'カスタムプロバイダーには少なくとも1つのモデルが必要です。',
+@@ -547,6 +550,7 @@ export const es = {
+   protocolOpenAiCompletions: 'Finalizaciones del chat OpenAI',
+   protocolOpenAiResponses: 'Respuestas de OpenAI',
+   protocolAnthropicMessages: 'Mensajes antrópicos',
++  omitReasoningInputStatus: 'Modo de compatibilidad de la puerta de enlace',
+   customNeedsBaseUrl: 'Un proveedor personalizado necesita una URL base.',
+   customBaseUrlInvalid: 'Ingrese una URL HTTP o HTTPS válida.',
+   customNeedsModels: 'Un proveedor personalizado necesita al menos un modelo.',
+@@ -688,6 +692,7 @@ export const fr = {
+   protocolOpenAiCompletions: 'Achèvements du chat OpenAI',
+   protocolOpenAiResponses: 'Réponses OpenAI',
+   protocolAnthropicMessages: 'Messages anthropiques',
++  omitReasoningInputStatus: 'Mode de compatibilité de la passerelle',
+   customNeedsBaseUrl: "Un fournisseur personnalisé a besoin d'une URL de base.",
+   customBaseUrlInvalid: 'Saisissez une URL HTTP ou HTTPS valide.',
+   customNeedsModels: "Un fournisseur personnalisé a besoin d'au moins un modèle.",
+@@ -829,6 +834,7 @@ export const de = {
+   protocolOpenAiCompletions: 'OpenAI-Chat-Abschlüsse',
+   protocolOpenAiResponses: 'OpenAI-Antworten',
+   protocolAnthropicMessages: 'Anthropische Botschaften',
++  omitReasoningInputStatus: 'Gateway-Kompatibilitätsmodus',
+   customNeedsBaseUrl: 'Ein benutzerdefinierter Anbieter benötigt eine Basis-URL.',
+   customBaseUrlInvalid: 'Geben Sie eine gültige HTTP- oder HTTPS-URL ein.',
+   customNeedsModels: 'Ein benutzerdefinierter Anbieter benötigt mindestens ein Modell.',
+@@ -970,6 +976,7 @@ export const ru = {
+   protocolOpenAiCompletions: 'Завершения чата OpenAI',
+   protocolOpenAiResponses: 'Ответы OpenAI',
+   protocolAnthropicMessages: 'Антропные сообщения',
++  omitReasoningInputStatus: 'Режим совместимости со шлюзом',
+   customNeedsBaseUrl: 'Пользовательскому поставщику нужен базовый URL-адрес.',
+   customBaseUrlInvalid: 'Введите действительный URL-адрес HTTP или HTTPS.',
+   customNeedsModels: 'Пользовательскому поставщику нужна хотя бы одна модель.',
+@@ -1111,6 +1118,7 @@ export const pt = {
+   protocolOpenAiCompletions: 'Conclusões do bate-papo OpenAI',
+   protocolOpenAiResponses: 'Respostas OpenAI',
+   protocolAnthropicMessages: 'Mensagens Antrópicas',
++  omitReasoningInputStatus: 'Modo de compatibilidade do gateway',
+   customNeedsBaseUrl: 'Um provedor personalizado precisa de um URL base.',
+   customBaseUrlInvalid: 'Insira um URL HTTP ou HTTPS válido.',
+   customNeedsModels: 'Um provedor personalizado precisa de pelo menos um modelo.',
+diff --git a/packages/llm/llm-pi-ai/src/adapter.ts b/packages/llm/llm-pi-ai/src/adapter.ts
+index 9c8b4d3f60..b179b11883 100644
+--- a/packages/llm/llm-pi-ai/src/adapter.ts
++++ b/packages/llm/llm-pi-ai/src/adapter.ts
+@@ -123,6 +123,24 @@ export interface PiAiAuthInjection {
+   authContext: AuthContext
+ }
+ 
++/** Whether one Responses input item is replayed reasoning with response status metadata. */
++function hasReasoningInputStatus(item: unknown): boolean {
++  const inputItem = item as Record<string, unknown>
++  return inputItem.type === 'reasoning' && Object.hasOwn(inputItem, 'status')
++}
++
++/** Remove response-only status metadata from replayed reasoning input items. */
++function omitReasoningInputStatus(payload: unknown): unknown {
++  const request = payload as Record<string, unknown> & { input: unknown[] }
++  if (!request.input.some(hasReasoningInputStatus)) return undefined
++  const input = request.input.map((item) => {
++    if (!hasReasoningInputStatus(item)) return item
++    const { status: _status, ...withoutStatus } = item as Record<string, unknown>
++    return withoutStatus
++  })
++  return { ...request, input }
++}
++
+ /** Copy profile stream knobs into pi-ai's common option vocabulary. */
+ function profileOptions(
+   profile: ResolvedPiAiProviderProfile,
+@@ -138,6 +156,7 @@ function profileOptions(
+     ...profile.transport === undefined ? {} : { transport: profile.transport },
+     ...profile.timeoutMs === undefined ? {} : { timeoutMs: profile.timeoutMs },
+     ...profile.websocketConnectTimeoutMs === undefined ? {} : { websocketConnectTimeoutMs: profile.websocketConnectTimeoutMs },
++    ...profile.responsesCompatibility?.omitReasoningInputStatus === true ? { onPayload: omitReasoningInputStatus } : {},
+     // The agent recovery layer owns visible attempts; one adapter call is one SDK attempt.
+     maxRetries: 0,
+   }
+diff --git a/packages/llm/llm-pi-ai/src/config.ts b/packages/llm/llm-pi-ai/src/config.ts
+index 3731e1bcc0..c0422f4d6f 100644
+--- a/packages/llm/llm-pi-ai/src/config.ts
++++ b/packages/llm/llm-pi-ai/src/config.ts
+@@ -88,6 +88,12 @@ export type {
+   PiAiThinkingFormat,
+ } from './catalog.ts'
+ 
++/** OpenAI Responses input-item adjustments for compatible gateways. */
++export interface PiAiResponsesCompatibility {
++  /** Omit response-only status metadata from replayed reasoning input items. */
++  omitReasoningInputStatus?: boolean
++}
++
+ /** Configuration for one pi-ai provider route; the `providers` dict key IS the route. */
+ export interface PiAiProviderProfile {
+   /** Credential reference (environment-variable name) resolved per request through `ctx.credentials`. */
+@@ -125,6 +131,8 @@ export interface PiAiProviderProfile {
+    * refused rather than left looking applied.
+    */
+   compat?: PiAiCompatProfile
++  /** OpenAI Responses input-item adjustments for compatible gateways. */
++  responsesCompatibility?: PiAiResponsesCompatibility
+   /**
+    * Context capacity for a model this route lists that neither the entry nor
+    * the installed catalog sizes (default 1,000,000). A guess by construction, so
+@@ -323,6 +331,10 @@ const modelProfile: z<PiAiModelProfile> = z.object({
+ /** A {@link modelProfile} whose id lives in the `modelOverrides` dict key. */
+ const modelOverride: z<PiAiModelOverride> = z.object(modelFields)
+ 
++const responsesCompatibility: z<PiAiResponsesCompatibility> = z.object({
++  omitReasoningInputStatus: z.boolean(),
++})
++
+ const profile = z.object({
+   apiKeyEnv: z.string().role('credential-ref'),
+   displayName: z.string(),
+@@ -331,6 +343,7 @@ const profile = z.object({
+   models: z.array(modelProfile),
+   modelOverrides: z.dict(modelOverride),
+   compat: compatProfile,
++  responsesCompatibility,
+   defaultContextWindow: z.number().step(1).min(1).default(DEFAULT_CONTEXT_WINDOW),
+   defaultMaxTokens: z.number().step(1).min(1).default(DEFAULT_MAX_TOKENS),
+   defaultInput: z.array(z.union(MODALITIES)).default([...DEFAULT_INPUT]),
+@@ -426,6 +439,11 @@ export function resolveProfiles(
+       throw new Error(`llm-pi-ai: provider "${provider}" has an empty displayName`)
+     }
+     assertValidHeaders(provider, source.headers)
++    if (source.responsesCompatibility?.omitReasoningInputStatus === true && source.api !== 'openai-responses') {
++      throw new Error(
++        `llm-pi-ai: provider "${provider}" responsesCompatibility.omitReasoningInputStatus requires api "openai-responses"`,
++      )
++    }
+     const streamIdleTimeoutMs = source.streamIdleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS
+     if (!Number.isFinite(streamIdleTimeoutMs)
+       || streamIdleTimeoutMs <= 0