mixdog 0.9.44 → 0.9.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.44",
+  "version": "0.9.46",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -94,7 +94,7 @@
     "diff": "^9.0.0",
     "discord.js": "^14.26.4",
     "ink": "^7.1.0",
-    "jsdom": "^26.1.0",
+    "jsdom": "^27.0.0",
     "kiwi-nlp": "^0.21.0",
     "marked": "^14.1.4",
     "node-cron": "^4.5.0",
@@ -115,6 +115,9 @@
     },
     "@discordjs/rest": {
       "undici": "6.27.0"
+    },
+    "onnxruntime-node": {
+      "global-agent": "^4.1.3"
     }
   },
   "devDependencies": {

package/scripts/agent-dispatch-abort-compose-test.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { composeAgentDispatchAbortSignal } from '../src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs';
+
+test('explore cancellation survives an active idle watchdog composite link', () => {
+    const factory = new AbortController();
+    const explore = new AbortController();
+    const idleWatchdog = new AbortController();
+    const linked = composeAgentDispatchAbortSignal([
+        factory.signal,
+        explore.signal,
+        idleWatchdog.signal,
+    ]);
+    const reason = new Error('explore ESC');
+    explore.abort(reason);
+    assert.equal(linked.signal.aborted, true);
+    assert.equal(linked.signal.reason, reason, 'per-call explore reason reaches the one session link');
+    assert.equal(idleWatchdog.signal.aborted, false, 'watchdog remains independently active');
+    linked.dispose();
+});
+
+test('an already-aborted parent reason is retained before the askSession controller swap', () => {
+    const factory = new AbortController();
+    const reason = new Error('factory canceled first');
+    factory.abort(reason);
+    const linked = composeAgentDispatchAbortSignal([factory.signal, new AbortController().signal]);
+    assert.equal(linked.signal.aborted, true);
+    assert.equal(linked.signal.reason, reason);
+    linked.dispose();
+});

package/scripts/agent-model-liveness-test.mjs

@@ -0,0 +1,618 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+
+import {
+    _clearSessionRuntime,
+    _getRuntimeEntry,
+    getSessionProgressSnapshot,
+    markSessionAskStart,
+    markSessionStreamDelta,
+} from '../src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs';
+import {
+    evaluateAgentWatchdogAbort,
+    resolveEffectiveToolRunningCeilingMs,
+} from '../src/runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
+import {
+    buildAgentTaskProgressFields,
+    formatAgentWatchdogSummary,
+} from '../src/standalone/agent-task-status.mjs';
+import {
+    consumeCompatChatCompletionStream,
+    consumeCompatResponsesStream,
+} from '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs';
+import { parseSSEStream } from '../src/runtime/agent/orchestrator/providers/anthropic-sse.mjs';
+import { _streamResponse } from '../src/runtime/agent/orchestrator/providers/openai-ws-stream.mjs';
+import { sendViaHttpSse } from '../src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs';
+import { shouldFallbackTransport } from '../src/runtime/agent/orchestrator/providers/retry-classifier.mjs';
+
+const policy = {
+    firstTransportMs: 120_000,
+    firstSemanticMs: 600_000,
+    idleStaleMs: 600_000,
+    toolRunningMs: 600_000,
+};
+
+function seededSnapshot(id, elapsedMs) {
+    markSessionAskStart(id);
+    const entry = _getRuntimeEntry(id);
+    const startedAt = Date.now() - elapsedMs;
+    entry.askStartedAt = startedAt;
+    entry.modelRequestStartedAt = startedAt;
+    entry.lastProgressAt = startedAt;
+    return { entry, snapshot: () => getSessionProgressSnapshot(id) };
+}
+
+test('independent first transport and semantic deadlines', async (t) => {
+    const id = `liveness-deadlines-${Date.now()}`;
+    t.after(() => _clearSessionRuntime(id));
+    const { entry, snapshot } = seededSnapshot(id, 121_000);
+    let err = evaluateAgentWatchdogAbort(snapshot(), Date.now(), policy);
+    assert.match(err?.message || '', /first transport stale \(120000ms\)/);
+
+    entry.lastTransportAt = Date.now();
+    err = evaluateAgentWatchdogAbort(snapshot(), entry.modelRequestStartedAt + 599_999, policy);
+    assert.equal(err, null, 'keepalive transport must not switch/reset the semantic deadline');
+    err = evaluateAgentWatchdogAbort(snapshot(), entry.modelRequestStartedAt + 600_001, policy);
+    assert.match(err?.message || '', /first semantic response stale \(600000ms\)/);
+
+    await markSessionStreamDelta(id, 'reasoning');
+    assert.equal(evaluateAgentWatchdogAbort(snapshot(), entry.modelRequestStartedAt + 700_000, policy), null);
+    assert.equal(snapshot().hasVisibleProgress, false);
+});
+
+test('status labels distinguish transport, semantic, reasoning, text, tool, and true stall', async (t) => {
+    const id = `liveness-status-${Date.now()}`;
+    t.after(() => _clearSessionRuntime(id));
+    const { entry, snapshot } = seededSnapshot(id, 10_000);
+    const fields = () => buildAgentTaskProgressFields({
+        now: Date.now(),
+        runtimeStage: entry.stage,
+        snapshot: snapshot(),
+        runtime: entry,
+        policy,
+    });
+
+    assert.equal(fields().last_progress, 'awaiting model transport');
+    assert.equal(fields().watchdog, 'armed transport=120s');
+    await markSessionStreamDelta(id, 'transport');
+    assert.equal(fields().last_progress, 'transport active; awaiting first model event');
+    assert.equal(fields().watchdog, 'armed semantic=600s');
+    await markSessionStreamDelta(id, 'semantic');
+    assert.equal(fields().last_progress, 'model active (no visible output yet)');
+    await markSessionStreamDelta(id, 'reasoning');
+    assert.equal(fields().last_progress, 'model reasoning (hidden; no visible output yet)');
+    assert.equal(fields().diagnostic, 'hidden reasoning active; no visible output yet');
+    await markSessionStreamDelta(id, 'text');
+    assert.equal(fields().last_progress, 'visible model text');
+    await markSessionStreamDelta(id, 'reasoning');
+    assert.equal(fields().last_progress, 'model reasoning (hidden; visible output previously emitted)');
+    await markSessionStreamDelta(id, 'tool');
+    entry.lastVisibleTextAt = null;
+    assert.equal(fields().last_progress, 'tool protocol progress');
+    assert.equal(formatAgentWatchdogSummary(policy), 'armed transport=120s semantic=600s idle=600s tool=600s');
+
+    entry.firstSemanticAt = null;
+    entry.lastSemanticAt = null;
+    entry.lastTransportAt = Date.now();
+    entry.modelRequestStartedAt = Date.now() - 600_001;
+    assert.match(fields().diagnostic, /^stale: first semantic response stale/);
+});
+
+test('tool-running status uses the same effective self-deadline ceiling as the watchdog', () => {
+    const snapshot = {
+        stage: 'tool_running',
+        toolStartedAt: 1_000,
+        currentTool: 'shell',
+        toolSelfDeadlineMs: 900_000,
+        lastProgressAt: 1_000,
+    };
+    const toolPolicy = { ...policy, idleStaleMs: 0 };
+    assert.equal(resolveEffectiveToolRunningCeilingMs(snapshot, toolPolicy), 960_000);
+    assert.equal(formatAgentWatchdogSummary(toolPolicy, snapshot), 'armed tool=960s');
+    assert.equal(evaluateAgentWatchdogAbort(snapshot, 961_000, toolPolicy), null);
+    assert.match(
+        evaluateAgentWatchdogAbort(snapshot, 961_001, toolPolicy)?.message || '',
+        /tool running stale \(960000ms\)/,
+    );
+});
+
+function asyncEvents(events) {
+    return { async *[Symbol.asyncIterator]() { for (const event of events) yield event; } };
+}
+
+function heartbeatOnlyStream(firstEvent, heartbeatEvent, intervalMs = 10) {
+    return {
+        async *[Symbol.asyncIterator]() {
+            yield firstEvent;
+            while (true) {
+                await new Promise((resolve) => setTimeout(resolve, intervalMs));
+                yield heartbeatEvent;
+            }
+        },
+    };
+}
+
+function closablePendingStream(firstEvent, { closeError = null } = {}) {
+    let delivered = false;
+    let returnCalls = 0;
+    const iterator = {
+        next() {
+            if (!delivered) {
+                delivered = true;
+                return Promise.resolve({ done: false, value: firstEvent });
+            }
+            return new Promise(() => {});
+        },
+        return() {
+            returnCalls += 1;
+            if (closeError) return Promise.reject(closeError);
+            return Promise.resolve({ done: true });
+        },
+    };
+    return {
+        stream: { [Symbol.asyncIterator]: () => iterator },
+        returnCalls: () => returnCalls,
+    };
+}
+
+async function assertCompatIteratorCloses({ kind, mode }) {
+    const firstEvent = kind === 'chat'
+        ? { choices: [{ delta: { role: 'assistant' } }] }
+        : { type: 'response.created', response: { id: 'r1', model: 'gpt' } };
+    const closeError = new Error(`${kind}-${mode} close failure`);
+    const pending = closablePendingStream(firstEvent, { closeError });
+    const controller = new AbortController();
+    const originalAbort = new Error(`${kind} original abort`);
+    const options = {
+        label: `${kind}-${mode}`,
+        signal: controller.signal,
+        semanticIdleTimeoutMs: 25,
+        ...(kind === 'responses'
+            ? { parseResponsesToolCalls: () => undefined, responseOutputText: () => '' }
+            : {}),
+    };
+    const consume = kind === 'chat'
+        ? consumeCompatChatCompletionStream
+        : consumeCompatResponsesStream;
+    const keepAlive = setInterval(() => {}, 10);
+    try {
+        const run = consume(pending.stream, options);
+        await new Promise((resolve) => setImmediate(resolve));
+        if (mode === 'abort') controller.abort(originalAbort);
+        if (mode === 'abort') {
+            await assert.rejects(run, (err) => err === originalAbort);
+        } else {
+            await assert.rejects(run, (err) => err?.name === 'StreamStalledError');
+        }
+        assert.equal(pending.returnCalls(), 1, `${kind} ${mode} must close iterator once`);
+    } finally {
+        clearInterval(keepAlive);
+    }
+}
+
+test('compat Chat/Responses watchdog and abort rejection close iterators without masking errors', async () => {
+    for (const kind of ['chat', 'responses']) {
+        for (const mode of ['abort', 'watchdog']) {
+            await assertCompatIteratorCloses({ kind, mode });
+        }
+    }
+});
+
+test('recovered Chat tool persists eager-dispatch safety across a later stream failure', async () => {
+    const original = new Error('compat stream failed after leaked tool dispatch');
+    let step = 0;
+    const stream = {
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    step += 1;
+                    if (step === 1) {
+                        return Promise.resolve({
+                            done: false,
+                            value: { choices: [{ delta: { content: '<invoke name="read"><parameter name="path">a.txt</parameter></invoke>' } }] },
+                        });
+                    }
+                    return Promise.reject(original);
+                },
+            };
+        },
+    };
+    const calls = [];
+    const rejected = await consumeCompatChatCompletionStream(stream, {
+        label: 'leaked-tool-failure',
+        knownToolNames: new Set(['read']),
+        onToolCall: (call) => calls.push(call),
+        parseToolCalls: () => undefined,
+    }).then(() => null, (err) => err);
+    assert.equal(rejected, original);
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].name, 'read');
+    assert.equal(rejected.emittedToolCall, true);
+    assert.equal(rejected.unsafeToRetry, true);
+    assert.equal(shouldFallbackTransport(rejected, { enabled: true }), false);
+
+    const truncatedCalls = [];
+    const truncated = await consumeCompatChatCompletionStream(asyncEvents([
+        { choices: [{ delta: { content: '<invoke name="read"><parameter name="path">b.txt</parameter></invoke>' } }] },
+    ]), {
+        label: 'leaked-tool-truncation',
+        knownToolNames: new Set(['read']),
+        onToolCall: (call) => truncatedCalls.push(call),
+        parseToolCalls: () => undefined,
+    }).then(() => null, (err) => err);
+    assert.equal(truncatedCalls.length, 1);
+    assert.equal(truncated.emittedToolCall, true);
+    assert.equal(truncated.unsafeToRetry, true);
+});
+
+test('compat Chat/Responses metadata heartbeats stay transport-only and cannot rearm semantic idle', async () => {
+    const chatKinds = [];
+    await assert.rejects(
+        consumeCompatChatCompletionStream(
+            heartbeatOnlyStream(
+                { choices: [{ delta: { role: 'assistant' } }] },
+                { id: 'meta', model: 'gpt', choices: [] },
+            ),
+            {
+                label: 'chat-heartbeat',
+                semanticIdleTimeoutMs: 45,
+                onStreamDelta: (kind) => chatKinds.push(kind),
+            },
+        ),
+        (err) => err?.name === 'StreamStalledError',
+    );
+    assert.deepEqual(chatKinds.filter((kind) => kind !== 'transport'), ['semantic']);
+    const chatSemanticIndex = chatKinds.indexOf('semantic');
+    assert.ok(chatSemanticIndex >= 0);
+    assert.ok(chatKinds.slice(chatSemanticIndex + 1).every((kind) => kind === 'transport'));
+
+    const responseKinds = [];
+    await assert.rejects(
+        consumeCompatResponsesStream(
+            heartbeatOnlyStream(
+                { type: 'response.created', response: { id: 'r1', model: 'gpt' } },
+                { type: 'response.in_progress', response: { id: 'r1' } },
+            ),
+            {
+                label: 'responses-heartbeat',
+                semanticIdleTimeoutMs: 45,
+                onStreamDelta: (kind) => responseKinds.push(kind),
+                parseResponsesToolCalls: () => undefined,
+                responseOutputText: () => '',
+            },
+        ),
+        (err) => err?.name === 'StreamStalledError',
+    );
+    assert.deepEqual(responseKinds.filter((kind) => kind !== 'transport'), ['semantic']);
+    const responseSemanticIndex = responseKinds.indexOf('semantic');
+    assert.ok(responseSemanticIndex >= 0);
+    assert.ok(responseKinds.slice(responseSemanticIndex + 1).every((kind) => kind === 'transport'));
+});
+
+test('OpenAI compat chat and Responses classify semantic progress without exposing reasoning', async () => {
+    const chatKinds = [];
+    const chat = await consumeCompatChatCompletionStream(asyncEvents([
+        { choices: [{ delta: { reasoning_content: 'secret' } }] },
+        { choices: [{ delta: { content: 'hello' } }] },
+        { choices: [{ delta: { tool_calls: [{ index: 0, id: 'call_1', function: { name: 'read', arguments: '{}' } }] }, finish_reason: 'tool_calls' }] },
+    ]), {
+        label: 'test',
+        onStreamDelta: (kind) => chatKinds.push(kind),
+        parseToolCalls: () => [{ id: 'call_1', name: 'read', arguments: {} }],
+    });
+    assert.ok(chatKinds.includes('transport'));
+    assert.ok(chatKinds.includes('reasoning'));
+    assert.ok(chatKinds.includes('text'));
+    assert.ok(chatKinds.includes('tool'));
+    assert.equal(chat.content, 'hello');
+    assert.equal(chat.reasoningContent, 'secret');
+
+    const responseKinds = [];
+    await consumeCompatResponsesStream(asyncEvents([
+        { type: 'response.created', response: { id: 'r1', model: 'gpt' } },
+        { type: 'response.reasoning_text.delta', delta: 'secret' },
+        { type: 'response.output_text.delta', delta: 'done' },
+        { type: 'response.completed', response: { id: 'r1', model: 'gpt', output: [] } },
+    ]), {
+        label: 'test',
+        onStreamDelta: (kind) => responseKinds.push(kind),
+        parseResponsesToolCalls: () => undefined,
+        responseOutputText: () => '',
+    });
+    assert.deepEqual(new Set(responseKinds), new Set(['transport', 'semantic', 'reasoning', 'text']));
+});
+
+const encoder = new TextEncoder();
+function anthropicResponse(events) {
+    const chunks = events.map((event) => encoder.encode(
+        `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`,
+    ));
+    let index = 0;
+    return { body: { getReader: () => ({
+        read: async () => index < chunks.length
+            ? { done: false, value: chunks[index++] }
+            : { done: true },
+        cancel: async () => {},
+        releaseLock: () => {},
+    }) } };
+}
+
+test('Anthropic classifies message_start, reasoning, text, and tool protocol with transport separate', async () => {
+    const kinds = [];
+    await parseSSEStream(anthropicResponse([
+        { type: 'message_start', message: { model: 'claude', usage: {} } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'thinking' } },
+        { type: 'content_block_delta', index: 0, delta: { type: 'thinking_delta', thinking: 'secret' } },
+        { type: 'content_block_start', index: 1, content_block: { type: 'text' } },
+        { type: 'content_block_delta', index: 1, delta: { type: 'text_delta', text: 'hello' } },
+        { type: 'content_block_start', index: 2, content_block: { type: 'tool_use', id: 't1', name: 'read' } },
+        { type: 'content_block_delta', index: 2, delta: { type: 'input_json_delta', partial_json: '{}' } },
+        { type: 'content_block_stop', index: 2 },
+        { type: 'message_delta', delta: { stop_reason: 'tool_use' }, usage: {} },
+    ]), null, () => {}, (kind) => kinds.push(kind), () => {}, {}, null);
+    assert.ok(kinds.includes('transport'));
+    assert.ok(kinds.includes('semantic'));
+    assert.ok(kinds.includes('reasoning'));
+    assert.ok(kinds.includes('text'));
+    assert.ok(kinds.includes('tool'));
+});
+
+test('Anthropic redacted_thinking is private reasoning and never visible text', async () => {
+    const kinds = [];
+    const visible = [];
+    const result = await parseSSEStream(anthropicResponse([
+        { type: 'message_start', message: { model: 'claude', usage: {} } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'redacted_thinking', data: 'opaque-secret' } },
+        { type: 'content_block_stop', index: 0 },
+        { type: 'message_delta', delta: { stop_reason: 'end_turn' }, usage: {} },
+        { type: 'message_stop' },
+    ]), null, () => {}, (kind) => kinds.push(kind), () => {}, {}, (text) => visible.push(text));
+    assert.ok(kinds.includes('reasoning'));
+    assert.equal(kinds.includes('text'), false);
+    assert.deepEqual(visible, []);
+    assert.equal(result.content, '');
+    assert.deepEqual(result.thinkingBlocks, [{ type: 'redacted_thinking', data: 'opaque-secret' }]);
+});
+
+class FakeSocket extends EventEmitter {
+    constructor() { super(); this.readyState = 1; }
+    close() {}
+    ping() {}
+    feed(events) { for (const event of events) this.emit('message', JSON.stringify(event)); }
+}
+
+function openAiHttpResponse(events) {
+    const chunks = events.map((event) => encoder.encode(
+        `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`,
+    ));
+    let index = 0;
+    return {
+        ok: true,
+        status: 200,
+        headers: new Map(),
+        body: { getReader: () => ({
+            read: async () => index < chunks.length
+                ? { done: false, value: chunks[index++] }
+                : { done: true },
+            cancel: async () => {},
+            releaseLock: () => {},
+        }) },
+    };
+}
+
+function wedgedOpenAiHttpResponse() {
+    return {
+        ok: true,
+        status: 200,
+        headers: new Map(),
+        body: { getReader: () => ({
+            read: () => new Promise(() => {}),
+            // Deliberately never settles: sendViaHttpSse must reject its own
+            // pending read race rather than trusting cancel().
+            cancel: () => new Promise(() => {}),
+            releaseLock: () => {},
+        }) },
+    };
+}
+
+test('OAuth HTTP SSE actively rejects a wedged reader on external and semantic aborts', async () => {
+    const keepAlive = setInterval(() => {}, 10);
+    try {
+    const startedAt = Date.now();
+    const external = new AbortController();
+    const externalReason = new Error('reviewer external abort');
+    const externalRun = sendViaHttpSse({
+        auth: { type: 'openai-direct', apiKey: 'test' },
+        body: {},
+        opts: {},
+        externalSignal: external.signal,
+        useModel: 'gpt',
+        fetchFn: async () => wedgedOpenAiHttpResponse(),
+    });
+    setTimeout(() => external.abort(externalReason), 10);
+    await assert.rejects(externalRun, (err) => err === externalReason);
+
+    const semanticRun = sendViaHttpSse({
+        auth: { type: 'openai-direct', apiKey: 'test' },
+        body: {},
+        opts: { _semanticIdleTimeoutMs: 25 },
+        useModel: 'gpt',
+        fetchFn: async () => wedgedOpenAiHttpResponse(),
+    });
+    await assert.rejects(semanticRun, (err) => (
+        err?.name === 'StreamStalledError'
+        && err?.streamStalled === true
+    ));
+    assert.ok(Date.now() - startedAt < 1_000, 'wedged reads must reject near their abort deadlines');
+    } finally {
+        clearInterval(keepAlive);
+    }
+});
+
+test('completion bundles report actual reasoning/text/tool kinds across compat, WS, and OAuth SSE', async () => {
+    const output = [
+        { type: 'reasoning', id: 'rs_1', encrypted_content: 'opaque', summary: [] },
+        { type: 'message', content: [{ type: 'output_text', text: 'final' }] },
+        { type: 'function_call', id: 'fc_1', call_id: 'call_1', name: 'read', arguments: '{}' },
+    ];
+
+    const compatKinds = [];
+    await consumeCompatResponsesStream(asyncEvents([
+        { type: 'response.created', response: { id: 'r1', model: 'gpt' } },
+        { type: 'response.completed', response: { id: 'r1', model: 'gpt', status: 'completed', output } },
+    ]), {
+        label: 'bundle-compat',
+        onStreamDelta: (kind) => compatKinds.push(kind),
+        parseResponsesToolCalls: () => undefined,
+        responseOutputText: () => 'final',
+    });
+    for (const kind of ['reasoning', 'text', 'tool']) assert.ok(compatKinds.includes(kind), `compat missing ${kind}`);
+
+    const wsKinds = [];
+    const socket = new FakeSocket();
+    const wsRun = _streamResponse({
+        entry: { socket },
+        state: {},
+        onStreamDelta: (kind) => wsKinds.push(kind),
+        _timeouts: { interChunkMs: 5_000, preResponseCreatedMs: 5_000, firstMeaningfulMs: 5_000 },
+    });
+    socket.feed([
+        { type: 'response.created', response: { id: 'r1', model: 'gpt' } },
+        { type: 'response.completed', response: { id: 'r1', model: 'gpt', output } },
+    ]);
+    await wsRun;
+    for (const kind of ['reasoning', 'text', 'tool']) assert.ok(wsKinds.includes(kind), `ws missing ${kind}`);
+
+    const oauthKinds = [];
+    await sendViaHttpSse({
+        auth: { type: 'openai-direct', apiKey: 'test' },
+        body: {},
+        opts: {},
+        useModel: 'gpt',
+        onStreamDelta: (kind) => oauthKinds.push(kind),
+        fetchFn: async () => openAiHttpResponse([
+            { type: 'response.created', response: { id: 'r1', model: 'gpt' } },
+            { type: 'response.completed', response: { id: 'r1', model: 'gpt', status: 'completed', output } },
+        ]),
+    });
+    for (const kind of ['reasoning', 'text', 'tool']) assert.ok(oauthKinds.includes(kind), `oauth missing ${kind}`);
+});
+
+const PURE_LEAK = '<invoke name="read"><parameter name="path">a.txt</parameter></invoke>';
+
+test('synthesized leaked tools report tool progress without visible-text progress', async () => {
+    const compatKinds = [];
+    const compatVisible = [];
+    await consumeCompatChatCompletionStream(asyncEvents([
+        { choices: [{ delta: { content: PURE_LEAK } }] },
+        { choices: [{ delta: {}, finish_reason: 'stop' }] },
+    ]), {
+        label: 'leak-compat',
+        knownToolNames: new Set(['read']),
+        onStreamDelta: (kind) => compatKinds.push(kind),
+        onTextDelta: (text) => compatVisible.push(text),
+        parseToolCalls: () => undefined,
+    });
+    assert.ok(compatKinds.includes('tool'));
+    assert.equal(compatKinds.includes('text'), false);
+    assert.deepEqual(compatVisible, []);
+
+    const compatResponseKinds = [];
+    const compatResponseVisible = [];
+    await consumeCompatResponsesStream(asyncEvents([
+        { type: 'response.created', response: { id: 'r1', model: 'gpt' } },
+        { type: 'response.output_text.delta', delta: PURE_LEAK },
+        { type: 'response.completed', response: { id: 'r1', model: 'gpt', status: 'completed', output: [] } },
+    ]), {
+        label: 'leak-compat-responses',
+        knownToolNames: new Set(['read']),
+        onStreamDelta: (kind) => compatResponseKinds.push(kind),
+        onTextDelta: (text) => compatResponseVisible.push(text),
+        parseResponsesToolCalls: () => undefined,
+        responseOutputText: () => '',
+    });
+    assert.ok(compatResponseKinds.includes('tool'));
+    assert.equal(compatResponseKinds.includes('text'), false);
+    assert.deepEqual(compatResponseVisible, []);
+
+    const anthropicKinds = [];
+    const anthropicVisible = [];
+    await parseSSEStream(anthropicResponse([
+        { type: 'message_start', message: { model: 'claude', usage: {} } },
+        { type: 'content_block_start', index: 0, content_block: { type: 'text' } },
+        { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: PURE_LEAK } },
+        { type: 'content_block_stop', index: 0 },
+        { type: 'message_delta', delta: { stop_reason: 'end_turn' }, usage: {} },
+        { type: 'message_stop' },
+    ]), null, () => {}, (kind) => anthropicKinds.push(kind), () => {}, {}, (text) => anthropicVisible.push(text), new Set(['read']));
+    assert.ok(anthropicKinds.includes('tool'));
+    assert.equal(anthropicKinds.includes('text'), false);
+    assert.deepEqual(anthropicVisible, []);
+
+    const wsKinds = [];
+    const wsVisible = [];
+    const socket = new FakeSocket();
+    const wsRun = _streamResponse({
+        entry: { socket },
+        state: {},
+        knownToolNames: new Set(['read']),
+        onStreamDelta: (kind) => wsKinds.push(kind),
+        onTextDelta: (text) => wsVisible.push(text),
+        _timeouts: { interChunkMs: 5_000, preResponseCreatedMs: 5_000, firstMeaningfulMs: 5_000 },
+    });
+    socket.feed([
+        { type: 'response.created', response: { id: 'r1', model: 'gpt' } },
+        { type: 'response.output_text.delta', delta: PURE_LEAK },
+        { type: 'response.completed', response: { id: 'r1', model: 'gpt', output: [] } },
+    ]);
+    await wsRun;
+    assert.ok(wsKinds.includes('tool'));
+    assert.equal(wsKinds.includes('text'), false);
+    assert.deepEqual(wsVisible, []);
+
+    const oauthKinds = [];
+    const oauthVisible = [];
+    await sendViaHttpSse({
+        auth: { type: 'openai-direct', apiKey: 'test' },
+        body: { tools: [{ name: 'read' }] },
+        opts: {},
+        useModel: 'gpt',
+        onStreamDelta: (kind) => oauthKinds.push(kind),
+        onTextDelta: (text) => oauthVisible.push(text),
+        fetchFn: async () => openAiHttpResponse([
+            { type: 'response.created', response: { id: 'r1', model: 'gpt' } },
+            { type: 'response.output_text.delta', delta: PURE_LEAK },
+            { type: 'response.completed', response: { id: 'r1', model: 'gpt', status: 'completed', output: [] } },
+        ]),
+    });
+    assert.ok(oauthKinds.includes('tool'));
+    assert.equal(oauthKinds.includes('text'), false);
+    assert.deepEqual(oauthVisible, []);
+});
+
+test('OpenAI WS reports transport plus semantic/reasoning/text classifications', async () => {
+    const id = `liveness-ws-${Date.now()}`;
+    const kinds = [];
+    const socket = new FakeSocket();
+    markSessionAskStart(id);
+    const p = _streamResponse({
+        entry: { socket },
+        state: { sessionId: id },
+        onStreamDelta: (kind) => kinds.push(kind),
+        _timeouts: { interChunkMs: 5_000, preResponseCreatedMs: 5_000, firstMeaningfulMs: 5_000 },
+    });
+    socket.feed([
+        { type: 'response.created', response: { id: 'r1', model: 'gpt' } },
+        { type: 'response.reasoning_text.delta', delta: 'secret' },
+        { type: 'response.output_text.delta', delta: 'hello' },
+        { type: 'response.completed', response: { id: 'r1', model: 'gpt', output: [] } },
+    ]);
+    await p;
+    assert.ok(_getRuntimeEntry(id)?.lastTransportAt);
+    assert.ok(kinds.includes('semantic'));
+    assert.ok(kinds.includes('reasoning'));
+    assert.ok(kinds.includes('text'));
+    _clearSessionRuntime(id);
+});