mixdog 0.7.18 → 0.8.1

package/src/agent/orchestrator/providers/openai-compat-stream.mjs

@@ -1,366 +0,0 @@
-import {
-    PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-    PROVIDER_SSE_IDLE_TIMEOUT_MS,
-    PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
-    createTimeoutSignal,
-    providerTimeoutError,
-} from '../stall-policy.mjs';
-import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
-
-function truncatedCompatStreamError(label, detail) {
-    return Object.assign(
-        new Error(`${label} SSE stream truncated${detail ? `: ${detail}` : ''}`),
-        { name: 'TruncatedStreamError', code: 'TRUNCATED_STREAM', truncatedStream: true },
-    );
-}
-
-/** Completed tool_call.arguments must be valid JSON; empty/missing → {}. */
-export function parseCompletedToolCallArgumentsJson(raw, label) {
-    const text = typeof raw === 'string' ? raw : (raw == null ? '' : String(raw));
-    const src = text === '' ? '{}' : text;
-    try {
-        return JSON.parse(src);
-    } catch {
-        throw truncatedCompatStreamError(label, 'invalid tool_call arguments JSON');
-    }
-}
-
-function firstByteCompatStreamError(label) {
-    const err = providerTimeoutError(`${label} first byte`, PROVIDER_FIRST_BYTE_TIMEOUT_MS);
-    err.firstByteTimeout = true;
-    return err;
-}
-
-async function nextAsyncWithWatchdog(iterator, { signal, idleMs, idleEnabled, idleLabel } = {}) {
-    let idleTimer = null;
-    let idleReject = null;
-    let idleTimedOut = false;
-    const armIdle = () => {
-        if (!idleEnabled || !(idleMs > 0)) return;
-        if (idleTimer) clearTimeout(idleTimer);
-        idleTimer = setTimeout(() => {
-            idleTimedOut = true;
-            const e = providerTimeoutError(idleLabel || 'compat SSE idle', idleMs);
-            e.code = 'ETIMEDOUT';
-            if (idleReject) {
-                const r = idleReject;
-                idleReject = null;
-                r(e);
-            }
-        }, idleMs);
-        if (typeof idleTimer.unref === 'function') idleTimer.unref();
-    };
-    armIdle();
-    try {
-        const result = await new Promise((resolve, reject) => {
-            idleReject = reject;
-            if (signal?.aborted) {
-                const reason = signal.reason;
-                reject(reason instanceof Error ? reason : new Error('compat stream aborted'));
-                return;
-            }
-            let onAbort = null;
-            if (signal) {
-                onAbort = () => {
-                    const reason = signal.reason;
-                    reject(reason instanceof Error ? reason : new Error('compat stream aborted'));
-                };
-                signal.addEventListener('abort', onAbort, { once: true });
-            }
-            iterator.next().then(
-                (value) => {
-                    if (idleTimer) clearTimeout(idleTimer);
-                    if (signal && onAbort) {
-                        try { signal.removeEventListener('abort', onAbort); } catch {}
-                    }
-                    resolve(value);
-                },
-                (err) => {
-                    if (idleTimer) clearTimeout(idleTimer);
-                    if (signal && onAbort) {
-                        try { signal.removeEventListener('abort', onAbort); } catch {}
-                    }
-                    reject(err);
-                },
-            );
-        });
-        return result;
-    } catch (err) {
-        if (idleTimer) clearTimeout(idleTimer);
-        if (idleTimedOut) throw providerTimeoutError(idleLabel || 'compat SSE idle', idleMs);
-        throw err;
-    }
-}
-
-function mergeToolCallDelta(accByIndex, deltaCalls) {
-    for (const tc of deltaCalls || []) {
-        const idx = Number.isFinite(Number(tc?.index)) ? Number(tc.index) : 0;
-        const prev = accByIndex.get(idx) || {
-            id: '',
-            type: 'function',
-            function: { name: '', arguments: '' },
-        };
-        if (tc.id) prev.id = tc.id;
-        if (tc.type) prev.type = tc.type;
-        if (tc.function?.name && !prev.function.name) prev.function.name = tc.function.name;
-        if (tc.function?.arguments) prev.function.arguments += tc.function.arguments;
-        accByIndex.set(idx, prev);
-    }
-}
-
-export function toolCallsFromStreamAcc(accByIndex, parseToolCalls, label) {
-    if (!accByIndex.size) return undefined;
-    const choice = {
-        message: {
-            tool_calls: [...accByIndex.entries()]
-                .sort((a, b) => a[0] - b[0])
-                .map(([, v]) => v),
-        },
-    };
-    return parseToolCalls(choice, label);
-}
-
-export async function consumeCompatChatCompletionStream(stream, { signal, label, onStreamDelta, parseToolCalls } = {}) {
-    const iterator = stream[Symbol.asyncIterator]();
-    const firstByteTimeout = createTimeoutSignal(signal, PROVIDER_FIRST_BYTE_TIMEOUT_MS, `${label} first byte`);
-    const idleEnabled = PROVIDER_SSE_IDLE_WATCHDOG_ENABLED;
-    const idleMs = PROVIDER_SSE_IDLE_TIMEOUT_MS;
-    let sawFirstEvent = false;
-    let content = '';
-    let reasoningContent = '';
-    let model = '';
-    let responseId = '';
-    let stopReason = null;
-    let rawUsage = null;
-    const toolAcc = new Map();
-    try {
-        while (true) {
-            const { value: chunk, done } = await nextAsyncWithWatchdog(iterator, {
-                // Until the first SSE chunk, bound the pending read to the
-                // first-byte timer (createTimeoutSignal already chains parent).
-                signal: sawFirstEvent ? signal : firstByteTimeout.signal,
-                idleMs,
-                idleEnabled: sawFirstEvent && idleEnabled,
-                idleLabel: `${label} SSE idle`,
-            });
-            if (done) break;
-            if (!sawFirstEvent) {
-                sawFirstEvent = true;
-                firstByteTimeout.cleanup();
-            }
-            try { onStreamDelta?.(); } catch {}
-            if (chunk?.id) responseId = chunk.id;
-            if (chunk?.model) model = chunk.model;
-            const choice = chunk?.choices?.[0];
-            if (choice?.delta?.content) content += choice.delta.content;
-            if (typeof choice?.delta?.reasoning_content === 'string') {
-                reasoningContent += choice.delta.reasoning_content;
-            }
-            mergeToolCallDelta(toolAcc, choice?.delta?.tool_calls);
-            if (choice?.finish_reason) stopReason = choice.finish_reason;
-            if (chunk?.usage) rawUsage = chunk.usage;
-        }
-    } finally {
-        firstByteTimeout.cleanup();
-    }
-    if (!sawFirstEvent) {
-        if (firstByteTimeout.signal?.aborted) throw firstByteCompatStreamError(label);
-        throw firstByteCompatStreamError(label);
-    }
-    if (!stopReason) {
-        throw truncatedCompatStreamError(label, 'no finish_reason');
-    }
-    const message = {
-        content: content || null,
-        ...(reasoningContent ? { reasoning_content: reasoningContent } : {}),
-    };
-    const rawToolCalls = [...toolAcc.entries()]
-        .sort((a, b) => a[0] - b[0])
-        .map(([, v]) => v)
-        .filter(tc => tc.id || tc.function?.name);
-    if (rawToolCalls.length) message.tool_calls = rawToolCalls;
-    const response = {
-        id: responseId || null,
-        model: model || null,
-        choices: [{ message, finish_reason: stopReason }],
-        usage: rawUsage || undefined,
-    };
-    return {
-        response,
-        model,
-        content,
-        toolCalls: toolCallsFromStreamAcc(toolAcc, parseToolCalls, label),
-        stopReason,
-        reasoningContent: reasoningContent || null,
-        rawUsage,
-    };
-}
-
-function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesToolCalls, responseOutputText, onStreamDelta }) {
-    if (!event || typeof event.type !== 'string') return;
-    switch (event.type) {
-        case 'response.created':
-            if (event.response?.model) state.model = event.response.model;
-            if (event.response?.id) state.responseId = event.response.id;
-            break;
-        case 'response.output_text.delta':
-            state.content += event.delta || '';
-            state.sawOutput = true;
-            try { onStreamDelta?.(); } catch {}
-            break;
-        case 'response.output_item.added':
-            if (event.item?.type === 'function_call') {
-                state.pendingCalls.set(event.item.id || '', {
-                    name: event.item.name || '',
-                    callId: event.item.call_id || '',
-                });
-            }
-            try { onStreamDelta?.(); } catch {}
-            break;
-        case 'response.function_call_arguments.delta':
-            try { onStreamDelta?.(); } catch {}
-            break;
-        case 'response.function_call_arguments.done': {
-            const itemId = event.item_id || '';
-            const pending = state.pendingCalls.get(itemId);
-            const call = {
-                id: pending?.callId || event.call_id || '',
-                name: pending?.name || event.name || '',
-                arguments: parseCompletedToolCallArgumentsJson(event.arguments, label),
-                _pendingItemId: itemId,
-            };
-            state.toolCalls.push(call);
-            if (call.id && call.name) delete call._pendingItemId;
-            try { onStreamDelta?.(); } catch {}
-            break;
-        }
-        case 'response.output_item.done': {
-            const item = event.item || {};
-            if (item.type === 'function_call') {
-                const tc = state.toolCalls.find(t => t._pendingItemId === (item.id || ''));
-                if (tc) {
-                    if (!tc.id && item.call_id) tc.id = item.call_id;
-                    if (!tc.name && item.name) tc.name = item.name;
-                    if (tc.id && tc.name) delete tc._pendingItemId;
-                } else if (item.call_id && item.name) {
-                    state.toolCalls.push({
-                        id: item.call_id,
-                        name: item.name,
-                        arguments: parseCompletedToolCallArgumentsJson(item.arguments, label),
-                    });
-                }
-            }
-            try { onStreamDelta?.(); } catch {}
-            break;
-        }
-        case 'response.completed': {
-            const resp = event.response || {};
-            state.completed = true;
-            state.completedResponse = resp;
-            if (!state.model && resp.model) state.model = resp.model;
-            if (!state.responseId && resp.id) state.responseId = resp.id;
-            if (!state.content) state.content = responseOutputText(resp);
-            if (!state.toolCalls.length) {
-                const parsed = parseResponsesToolCalls(resp, label);
-                if (parsed?.length) state.toolCalls.push(...parsed.map(t => ({ ...t })));
-            }
-            try { onStreamDelta?.(); } catch {}
-            break;
-        }
-        case 'response.done':
-            if (!event.response || event.response.status === 'completed') state.completed = true;
-            else if (event.response.status === 'failed') {
-                const msg = event.response?.error?.message || 'response.done failed';
-                const err = new Error(`xAI Responses stream response.done failed: ${msg}`);
-                populateHttpStatusFromMessage(err, msg);
-                throw err;
-            } else if (event.response.status === 'incomplete') {
-                throw new Error(`xAI Responses stream response.done incomplete: ${event.response?.incomplete_details?.reason || 'incomplete'}`);
-            }
-            break;
-        case 'response.failed': {
-            const msg = event.response?.error?.message || event.error?.message || event.message || 'response.failed';
-            const err = new Error(`xAI Responses stream response.failed: ${msg}`);
-            populateHttpStatusFromMessage(err, msg);
-            throw err;
-        }
-        case 'response.incomplete':
-            throw new Error(`xAI Responses stream response.incomplete: ${event.response?.incomplete_details?.reason || 'incomplete'}`);
-        case 'error': {
-            const msg = event.message || event.error?.message || 'unknown';
-            const err = new Error(`xAI Responses stream error: ${msg}`);
-            populateHttpStatusFromMessage(err, msg);
-            throw err;
-        }
-        default:
-            break;
-    }
-}
-
-export async function consumeCompatResponsesStream(stream, {
-    signal,
-    label,
-    onStreamDelta,
-    parseResponsesToolCalls,
-    responseOutputText,
-} = {}) {
-    const iterator = stream[Symbol.asyncIterator]();
-    const firstByteTimeout = createTimeoutSignal(signal, PROVIDER_FIRST_BYTE_TIMEOUT_MS, `${label} first byte`);
-    const idleEnabled = PROVIDER_SSE_IDLE_WATCHDOG_ENABLED;
-    const idleMs = PROVIDER_SSE_IDLE_TIMEOUT_MS;
-    const state = {
-        content: '',
-        model: '',
-        responseId: '',
-        toolCalls: [],
-        pendingCalls: new Map(),
-        completed: false,
-        completedResponse: null,
-        sawOutput: false,
-    };
-    let sawFirstEvent = false;
-    const deps = { label, parseResponsesToolCalls, responseOutputText, onStreamDelta };
-    try {
-        while (true) {
-            const { value: event, done } = await nextAsyncWithWatchdog(iterator, {
-                signal: sawFirstEvent ? signal : firstByteTimeout.signal,
-                idleMs,
-                idleEnabled: sawFirstEvent && idleEnabled,
-                idleLabel: `${label} SSE idle`,
-            });
-            if (done) break;
-            if (!sawFirstEvent) {
-                sawFirstEvent = true;
-                firstByteTimeout.cleanup();
-            }
-            handleCompatResponsesStreamEvent(event, state, deps);
-        }
-    } finally {
-        firstByteTimeout.cleanup();
-    }
-    if (!sawFirstEvent) {
-        if (firstByteTimeout.signal?.aborted) throw firstByteCompatStreamError(label);
-        throw firstByteCompatStreamError(label);
-    }
-    if (!state.completed) throw truncatedCompatStreamError(label, 'no response.completed');
-    const unresolved = state.toolCalls.find(t => t._pendingItemId);
-    if (unresolved) {
-        throw new Error(`xAI Responses stream function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`);
-    }
-    const response = state.completedResponse || {
-        id: state.responseId || null,
-        model: state.model || null,
-        output_text: state.content,
-        output: [],
-    };
-    const toolCalls = state.toolCalls.length
-        ? state.toolCalls.map(({ _pendingItemId, ...t }) => t)
-        : parseResponsesToolCalls(response, label);
-    return {
-        response,
-        content: state.content || responseOutputText(response),
-        toolCalls,
-        model: state.model || response.model || null,
-        responseId: state.responseId || response.id || null,
-    };
-}