chore: establish YCode replication baseline and TODO

scripts/omp-provider-error-regression.ts

@@ -0,0 +1,90 @@
+import assert from 'node:assert/strict'
+import { EventEmitter } from 'node:events'
+import { runOmpTurn } from '../src/main/agent/omp-turn'
+import type { OmpKernel } from '../src/main/omp'
+import type { ChatEvent } from '../src/shared/types'
+
+class Kernel extends EventEmitter {
+  abortCalls = 0
+  disposeCalls = 0
+  rejectAbort = false
+  async prompt(): Promise<{ type: string; success: boolean }> { return { type: 'response', success: true } }
+  async abort(): Promise<void> { this.abortCalls++; if (this.rejectAbort) throw new Error('abort unavailable') }
+  async dispose(): Promise<void> { this.disposeCalls++ }
+}
+function begin(kernel = new Kernel(), controller = new AbortController()) {
+  const events: ChatEvent[] = []
+  const outcome = runOmpTurn({ kernel: kernel as unknown as OmpKernel, runId: 'provider-error',
+    userText: 'fixture', signal: controller.signal, emit: event => events.push(event) })
+    .then(value => ({ value, error: undefined }), (error: Error) => ({ value: undefined, error }))
+  return { kernel, controller, events, outcome }
+}
+const errorMessage = { role: 'assistant', stopReason: 'error', content: [], errorMessage: 'Unable to connect. Is the computer able to access the url?' }
+const emit = (kernel: Kernel, frame: Record<string, unknown>): void => { kernel.emit('event', frame) }
+const delay = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 15))
+
+{
+  const test = begin()
+  emit(test.kernel, { type: 'message_end', message: errorMessage })
+  const result = await test.outcome
+  assert.equal(result.error?.message, errorMessage.errorMessage)
+  assert.equal(test.kernel.abortCalls, 1)
+  assert.equal(test.events.filter(event => event.type === 'error').length, 1)
+  emit(test.kernel, { type: 'agent_end', yielded: false, messages: [errorMessage] })
+  emit(test.kernel, { type: 'agent_end', yielded: true })
+  assert.equal(test.events.filter(event => ['done', 'cancelled'].includes(event.type)).length, 0)
+  assert.equal(test.kernel.listenerCount('event'), 0)
+  assert.equal(test.kernel.listenerCount('error'), 0)
+}
+{
+  const test = begin()
+  emit(test.kernel, { type: 'agent_end', yielded: false, messages: [{ role: 'user' }, errorMessage] })
+  assert.equal((await test.outcome).error?.message, errorMessage.errorMessage)
+  assert.equal(test.kernel.abortCalls, 1)
+}
+{
+  const test = begin()
+  emit(test.kernel, { type: 'message_end', message: { ...errorMessage, errorMessage: 'Failed https://account:secret@example.invalid/v1?key=url-secret API Key: field-secret Authorization: Bearer bearer-secret sk-plainsecret123' } })
+  const message = (await test.outcome).error!.message
+  for (const secret of ['account', 'secret@example', 'url-secret', 'field-secret', 'bearer-secret', 'plainsecret123']) assert.equal(message.includes(secret), false)
+  assert.match(message, /已隐藏/)
+}
+{
+  const test = begin()
+  test.controller.abort()
+  emit(test.kernel, { type: 'message_end', message: errorMessage })
+  assert.equal((await test.outcome).value?.status, 'cancelled')
+  assert.equal(test.events.some(event => event.type === 'error'), false)
+  assert.equal(test.events.filter(event => event.type === 'cancelled').length, 1)
+  assert.equal(test.kernel.abortCalls, 1)
+}
+{
+  const test = begin()
+  let ended = false
+  void test.outcome.then(() => { ended = true })
+  // There is no first-byte deadline: long thinking and tool-level failures remain live.
+  emit(test.kernel, { type: 'message_update', assistantMessageEvent: { type: 'thinking_delta', delta: 'thinking', contentIndex: 0 } })
+  emit(test.kernel, { type: 'message_end', message: { ...errorMessage, role: 'toolResult' } })
+  emit(test.kernel, { type: 'tool_execution_start', toolCallId: 'tool', toolName: 'shell', args: {} })
+  emit(test.kernel, { type: 'tool_execution_end', toolCallId: 'tool', toolName: 'shell', isError: true, result: { content: [{ type: 'text', text: 'command failed' }] } })
+  emit(test.kernel, { type: 'agent_end', yielded: false, messages: [{ role: 'assistant', stopReason: 'toolUse' }] })
+  await delay()
+  assert.equal(ended, false)
+  assert.equal(test.kernel.abortCalls, 0)
+  assert.equal(test.events.some(event => event.type === 'error'), false)
+  emit(test.kernel, { type: 'message_update', assistantMessageEvent: { type: 'text_delta', delta: 'recovered' } })
+  emit(test.kernel, { type: 'agent_end', yielded: true, messages: [errorMessage, { role: 'assistant', stopReason: 'stop' }] })
+  const result = (await test.outcome).value!
+  assert.equal(result.status, 'done')
+  assert.equal(result.content, 'recovered')
+  assert.equal(result.tools[0].status, 'error')
+}
+{
+  const test = begin()
+  test.kernel.rejectAbort = true
+  emit(test.kernel, { type: 'message_end', message: { role: 'assistant', stopReason: 'error' } })
+  assert.equal((await test.outcome).error?.message, 'OMP 模型服务请求失败')
+  await delay()
+  assert.equal(test.kernel.disposeCalls, 1, 'failed abort disposes the sidecar instead of leaving automatic retries running')
+}
+console.log('omp-provider-error-regression: provider error, retry stop, sanitization, cancellation, long thinking, and tool error isolation passed (protocol fixtures; no real upstream request)')