@loicngr/kobo 2.1.29 → 2.1.30

package/dist/server/services/agent/engines/mistral-vibe/engine.js

@@ -0,0 +1,361 @@
+import { randomUUID } from 'node:crypto';
+import * as acp from '@agentclientprotocol/sdk';
+import { isWorkspacePermissionAllowed } from '../../../workspace-permission-policy-service.js';
+import { createTurnLiveness } from '../../turn-liveness.js';
+import { AGENT_NO_LONGER_RUNNING_TEXT } from '../types.js';
+import { MISTRAL_CAPABILITIES } from './capabilities.js';
+import { closeVibeAcpSession, connectVibeAcp, requestVibeAcp } from './client.js';
+import { readMistralSelect, requireMistralOption } from './configuration.js';
+import { createMistralEventMapper } from './event-mapper.js';
+import { buildMistralOptions } from './options-builder.js';
+import { createMistralServerRequests } from './server-requests.js';
+import { spawnVibeAcp } from './spawn.js';
+function receipt() {
+    let resolve;
+    let reject;
+    const promise = new Promise((yes, no) => {
+        resolve = yes;
+        reject = no;
+    });
+    void promise.catch(() => { });
+    return { promise, resolve, reject };
+}
+function record(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function invalidResponse() {
+    throw new Error('Invalid Vibe ACP setup response');
+}
+function diagnostic(error, stage) {
+    const message = error instanceof Error ? error.message : '';
+    if (/missing.*api.?key|auth|credential|\b401\b|\b403\b/i.test(message))
+        return {
+            kind: 'error',
+            category: 'other',
+            code: 'acp_auth_required',
+            message: 'Mistral Vibe authentication is required; check the native Vibe authentication configuration for the server user.',
+        };
+    if (/quota|rate.?limit|\b429\b/i.test(message))
+        return {
+            kind: 'error',
+            category: 'quota',
+            code: 'acp_quota',
+            message: 'Mistral Vibe reported a quota or rate limit; check the provider limits before retrying.',
+        };
+    if (/^Mistral Vibe .*selection is unavailable/.test(message))
+        return { kind: 'error', category: 'other', code: 'acp_configuration_unavailable', message };
+    if (/Invalid Vibe ACP/i.test(message))
+        return {
+            kind: 'error',
+            category: 'parse_error',
+            code: 'acp_invalid_response',
+            message: 'Mistral Vibe returned an incompatible ACP response; ACP v1 and supported native modes are required.',
+        };
+    // resume_failed clears native identity and permits a fresh auto-loop conversation.
+    if (stage === 'load')
+        return {
+            kind: 'error',
+            category: 'other',
+            code: 'acp_load_failed',
+            message: 'Mistral Vibe could not load the saved session. No new conversation was started.',
+        };
+    return {
+        kind: 'error',
+        category: stage === 'connect' ? 'spawn_failed' : 'other',
+        code: `acp_${stage}_failed`,
+        message: `Mistral Vibe ${stage} failed. Check the native executable, configuration and provider connection before retrying.`,
+    };
+}
+export function createMistralVibeEngine() {
+    return {
+        id: 'mistral-vibe',
+        displayName: 'Mistral Vibe',
+        capabilities: MISTRAL_CAPABILITIES,
+        async start(options, onEvent) {
+            // All unsupported launch choices fail before runtime ownership exists.
+            const built = buildMistralOptions(options);
+            const runtime = spawnVibeAcp({ cwd: built.cwd, env: built.env });
+            const ready = receipt();
+            const accepted = receipt();
+            let connection;
+            let sessionId = options.resumeFromEngineSessionId;
+            let canClose = false;
+            let active = false;
+            let live = false;
+            let ended = false;
+            let physicallyClosed = false;
+            let mappedError = false;
+            let shutdownPromise;
+            const tools = new Set();
+            const liveness = createTurnLiveness({
+                timeoutMs: 120_000,
+                enabled: options.watchdogEnabled === true,
+                onTimeout: () => end('watchdog', {
+                    kind: 'error',
+                    category: 'other',
+                    code: 'acp_watchdog',
+                    message: 'Mistral Vibe stopped reporting foreground activity for this turn.',
+                }),
+            });
+            const emit = (event) => {
+                if (ended)
+                    return;
+                if (event.kind === 'message:text' ||
+                    event.kind === 'message:thinking' ||
+                    event.kind === 'tool:call' ||
+                    event.kind === 'tool:result') {
+                    if (event.kind === 'tool:call')
+                        tools.add(event.toolCallId);
+                    if (event.kind === 'tool:result')
+                        tools.delete(event.toolCallId);
+                    liveness.setTimeoutMs(tools.size ? 30 * 60_000 : 120_000);
+                    liveness.activity();
+                }
+                if (event.kind === 'error') {
+                    mappedError = true;
+                    // Typed native notices may include provider details; expose fixed actionable diagnostics.
+                    if (!event.code && event.category !== 'parse_error')
+                        event = diagnostic(new Error(event.message), 'prompt');
+                }
+                onEvent(event);
+            };
+            const mapper = createMistralEventMapper(randomUUID(), emit);
+            let requests;
+            const shutdown = () => {
+                if (!shutdownPromise) {
+                    shutdownPromise = runtime.stop(connection && sessionId
+                        ? () => closeVibeAcpSession(connection, { sessionId: sessionId, active, canClose })
+                        : undefined);
+                    void shutdownPromise.catch(() => { });
+                }
+                return shutdownPromise;
+            };
+            function end(reason, error) {
+                if (ended)
+                    return;
+                liveness.stop();
+                requests?.cancelAll();
+                mapper.flush();
+                if (error)
+                    emit(error);
+                ended = true;
+                const failure = new Error(error?.message ?? 'Mistral Vibe ended before initial prompt consumption was confirmed');
+                ready.reject(failure);
+                accepted.reject(failure);
+                if (reason === 'completed')
+                    onEvent({ kind: 'turn:completed' });
+                onEvent({ kind: 'session:ended', reason, exitCode: reason === 'completed' ? 0 : null });
+                void shutdown();
+            }
+            const onClose = () => {
+                if (!ended)
+                    end('error', diagnostic(new Error('Native transport closed'), active ? 'prompt' : 'setup'));
+            };
+            runtime.child.once('close', onClose);
+            void runtime.closed
+                .then(() => {
+                physicallyClosed = true;
+                onClose();
+                runtime.child.removeListener('close', onClose);
+                // SDK close cancels its receive reader; only do this after native EOF cleanup.
+                connection?.close();
+            })
+                .catch(() => { });
+            const run = async () => {
+                let stage = 'connect';
+                try {
+                    connection = connectVibeAcp(runtime.child, {
+                        sessionUpdate: ({ params }) => {
+                            if (ended || !sessionId || params.sessionId !== sessionId)
+                                return;
+                            // Plans synthesize tool events; only native foreground signals prove prompt consumption.
+                            const update = params.update;
+                            if (live &&
+                                (update.sessionUpdate === 'tool_call' ||
+                                    update.sessionUpdate === 'tool_call_update' ||
+                                    ((update.sessionUpdate === 'agent_message_chunk' || update.sessionUpdate === 'agent_thought_chunk') &&
+                                        update.content.type === 'text' &&
+                                        update.content.text.length > 0)))
+                                accepted.resolve();
+                            mapper.onUpdate(params);
+                            if (live &&
+                                [
+                                    'agent_message_chunk',
+                                    'agent_thought_chunk',
+                                    'tool_call',
+                                    'tool_call_update',
+                                    'plan',
+                                    'compaction_update',
+                                ].includes(params.update.sessionUpdate))
+                                liveness.activity();
+                        },
+                        requestPermission: (context) => live && !ended && requests ? requests.requestPermission(context) : { outcome: { outcome: 'cancelled' } },
+                        createElicitation: (context) => live && !ended && requests ? requests.createElicitation(context) : { action: 'cancel' },
+                    });
+                    void connection.closed.then(onClose, onClose);
+                    stage = 'initialize';
+                    const initialized = await requestVibeAcp(connection, acp.methods.agent.initialize, {
+                        protocolVersion: acp.PROTOCOL_VERSION,
+                        clientCapabilities: { elicitation: { form: {} } },
+                    });
+                    if (ended)
+                        return;
+                    if (!record(initialized) ||
+                        initialized.protocolVersion !== acp.PROTOCOL_VERSION ||
+                        !record(initialized.agentCapabilities))
+                        invalidResponse();
+                    const capabilities = initialized.agentCapabilities;
+                    if (capabilities.loadSession != null && typeof capabilities.loadSession !== 'boolean')
+                        invalidResponse();
+                    if (capabilities.sessionCapabilities != null && !record(capabilities.sessionCapabilities))
+                        invalidResponse();
+                    const close = capabilities.sessionCapabilities?.close;
+                    if (close != null && !record(close))
+                        invalidResponse();
+                    canClose = close != null;
+                    if (options.resumeFromEngineSessionId && capabilities.loadSession !== true)
+                        invalidResponse();
+                    stage = options.resumeFromEngineSessionId ? 'load' : 'setup';
+                    const params = { cwd: built.cwd, mcpServers: built.mcpServers };
+                    const session = options.resumeFromEngineSessionId
+                        ? await requestVibeAcp(connection, acp.methods.agent.session.load, {
+                            ...params,
+                            sessionId: options.resumeFromEngineSessionId,
+                        })
+                        : await requestVibeAcp(connection, acp.methods.agent.session.new, params);
+                    if (ended)
+                        return;
+                    if (!record(session))
+                        invalidResponse();
+                    if (!options.resumeFromEngineSessionId) {
+                        if (!('sessionId' in session) || typeof session.sessionId !== 'string' || !session.sessionId.trim())
+                            invalidResponse();
+                        sessionId = session.sessionId;
+                    }
+                    if (!sessionId ||
+                        !record(session.modes) ||
+                        typeof session.modes.currentModeId !== 'string' ||
+                        !Array.isArray(session.modes.availableModes) ||
+                        !session.modes.availableModes.every((mode) => record(mode) && typeof mode.id === 'string') ||
+                        !session.modes.availableModes.some((mode) => mode.id === built.modeId))
+                        invalidResponse();
+                    requireMistralOption(session, 'mode', built.modeId);
+                    readMistralSelect(session, 'model', false);
+                    requests = createMistralServerRequests({
+                        sessionId,
+                        readOnly: false,
+                        emit,
+                        getTool: mapper.getTool,
+                        canonicalToolCallId: mapper.canonicalToolCallId,
+                        autoApprove: (toolName, payload) => isWorkspacePermissionAllowed(options.workspaceId, { engine: 'mistral-vibe', toolName, payload }),
+                        onPendingChange: (count) => {
+                            if (count > 0)
+                                liveness.pause();
+                            else if (!ended)
+                                liveness.resume();
+                        },
+                    });
+                    stage = 'configuration';
+                    let configured = await requestVibeAcp(connection, acp.methods.agent.session.setConfigOption, {
+                        sessionId,
+                        configId: 'mode',
+                        value: built.modeId,
+                    });
+                    if (ended)
+                        return;
+                    requireMistralOption(configured, 'mode', built.modeId, true);
+                    for (const [configId, value] of [
+                        ['model', options.model],
+                        ['thinking', options.effort],
+                    ]) {
+                        if (!value || value === 'auto')
+                            continue;
+                        requireMistralOption(configured, configId, value);
+                        configured = await requestVibeAcp(connection, acp.methods.agent.session.setConfigOption, {
+                            sessionId,
+                            configId,
+                            value,
+                        });
+                        if (ended)
+                            return;
+                        requireMistralOption(configured, configId, value, true);
+                        requireMistralOption(configured, 'mode', built.modeId, true);
+                    }
+                    if (options.model && options.model !== 'auto')
+                        requireMistralOption(configured, 'model', options.model, true);
+                    const model = readMistralSelect(configured, 'model', false)?.currentValue;
+                    try {
+                        options.onPromptPrepared?.(built.koboInstructions);
+                    }
+                    catch {
+                        console.warn('[mistral-vibe] Could not persist prepared launch instructions');
+                    }
+                    if (ended)
+                        return;
+                    emit({ kind: 'session:started', engineSessionId: sessionId, ...(model ? { model } : {}) });
+                    if (ended)
+                        return;
+                    stage = 'prompt';
+                    active = true;
+                    live = true;
+                    mapper.beginLive();
+                    liveness.start();
+                    const pending = requestVibeAcp(connection, acp.methods.agent.session.prompt, {
+                        sessionId,
+                        prompt: built.prompt,
+                    });
+                    ready.resolve();
+                    const result = await pending;
+                    if (ended)
+                        return;
+                    active = false;
+                    mapper.finish(result);
+                    if (result.stopReason === 'end_turn' && !mappedError) {
+                        accepted.resolve();
+                        end('completed');
+                    }
+                    else if (result.stopReason === 'cancelled') {
+                        end('error', {
+                            kind: 'error',
+                            category: 'other',
+                            code: 'acp_cancelled',
+                            message: 'Mistral Vibe cancelled the prompt without a local stop request.',
+                        });
+                    }
+                    else
+                        end('error');
+                }
+                catch (error) {
+                    if (!ended)
+                        end('error', diagnostic(error, stage));
+                }
+            };
+            // start() must return ownership even when asynchronous setup/cleanup fails.
+            void run();
+            return {
+                ready: ready.promise,
+                initialPromptAccepted: accepted.promise,
+                closed: runtime.closed,
+                pid: runtime.child.pid,
+                get engineSessionId() {
+                    return sessionId;
+                },
+                isAlive: () => !physicallyClosed,
+                sendMessage() {
+                    if (physicallyClosed)
+                        throw new Error(`Mistral Vibe ${AGENT_NO_LONGER_RUNNING_TEXT}`);
+                    throw new Error('Mistral Vibe live message delivery is unsupported; wait for native closure and resume the conversation');
+                },
+                interrupt() {
+                    end('killed');
+                },
+                stop() {
+                    end('killed');
+                    return shutdown();
+                },
+                hasPendingUserInput: (id) => requests?.hasPendingUserInput(id) ?? false,
+                resolvePendingUserInput: (id, response) => requests?.resolvePendingUserInput(id, response) ?? false,
+            };
+        },
+    };
+}

package/dist/server/services/agent/engines/mistral-vibe/event-mapper.js

@@ -0,0 +1,297 @@
+import { createStreamingBatcher } from '../../streaming-batcher.js';
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function validTokens(inputTokens, outputTokens) {
+    return typeof inputTokens === 'number' &&
+        Number.isSafeInteger(inputTokens) &&
+        inputTokens >= 0 &&
+        typeof outputTokens === 'number' &&
+        Number.isSafeInteger(outputTokens) &&
+        outputTokens >= 0
+        ? { inputTokens, outputTokens }
+        : undefined;
+}
+function validCost(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+function toolName(tool) {
+    const name = tool._meta?.tool_name;
+    return typeof name === 'string' && name.trim() ? name : tool.name?.trim() || undefined;
+}
+const BRAINSTORM_COMPLETE = '[BRAINSTORM_COMPLETE]';
+/** One owned session and prompt per launch; the engine filters native session IDs before dispatch. */
+export function createMistralEventMapper(launchId, emit) {
+    const scoped = (kind, id) => `vibe:${encodeURIComponent(launchId)}:${kind}:${encodeURIComponent(id)}`;
+    const canonicalToolCallId = (nativeId) => scoped('tool', nativeId);
+    const batcher = createStreamingBatcher(emit);
+    const tools = new Map();
+    const compactions = new Map();
+    let live = false;
+    let finished = false;
+    let messageId;
+    let messageKind;
+    let messageSequence = 0;
+    let planSequence = 0;
+    let brainstormTail = '';
+    let brainstormEmitted = false;
+    let baseline;
+    let baselineCost;
+    let latest;
+    let latestCost;
+    let sawLiveTokens = false;
+    let sawLiveCost = false;
+    let tokensReset = false;
+    let costReset = false;
+    function captureTokens(input, output) {
+        const tokens = validTokens(input, output);
+        if (!tokens) {
+            if (live)
+                tokensReset = true;
+            else
+                latest = undefined;
+            return;
+        }
+        if (live) {
+            sawLiveTokens = true;
+            if (latest && (tokens.inputTokens < latest.inputTokens || tokens.outputTokens < latest.outputTokens))
+                tokensReset = true;
+        }
+        latest = tokens;
+    }
+    function captureUsage(update) {
+        const meta = update._meta;
+        if (meta && ('promptTokens' in meta || 'completionTokens' in meta))
+            captureTokens(meta.promptTokens, meta.completionTokens);
+        if (update.cost) {
+            if (update.cost.currency !== 'USD' || !validCost(update.cost.amount)) {
+                if (live)
+                    costReset = true;
+                else
+                    latestCost = undefined;
+            }
+            else {
+                if (live) {
+                    sawLiveCost = true;
+                    if (latestCost !== undefined && update.cost.amount < latestCost)
+                        costReset = true;
+                }
+                latestCost = update.cost.amount;
+            }
+        }
+    }
+    function closeMessage() {
+        if (messageId)
+            batcher.push({ kind: 'message:end', messageId });
+        messageId = undefined;
+        messageKind = undefined;
+        brainstormTail = '';
+    }
+    function emitTool(tracked, force = false) {
+        if ((!tracked.callReady && !force) || tracked.resultEmitted)
+            return;
+        const { tool } = tracked;
+        const toolCallId = canonicalToolCallId(tool.toolCallId);
+        if (!tracked.callEmitted) {
+            tracked.callEmitted = true;
+            batcher.push({
+                kind: 'tool:call',
+                messageId: '',
+                toolCallId,
+                name: toolName(tool) ?? (tool.title || 'Tool'),
+                input: tool.rawInput,
+            });
+        }
+        if (tool.status === 'completed' || tool.status === 'failed') {
+            tracked.resultEmitted = true;
+            const output = tool.content?.length || tool.locations?.length
+                ? {
+                    ...(tool.rawOutput !== undefined ? { rawOutput: tool.rawOutput } : {}),
+                    ...(tool.content?.length ? { content: tool.content } : {}),
+                    ...(tool.locations?.length ? { locations: tool.locations } : {}),
+                }
+                : (tool.rawOutput ?? null);
+            batcher.push({ kind: 'tool:result', toolCallId, output, isError: tool.status === 'failed' });
+        }
+    }
+    function mergeTool(update) {
+        let tracked = tools.get(update.toolCallId);
+        if (!tracked) {
+            tracked = {
+                tool: { toolCallId: update.toolCallId, title: '' },
+                hasMetadata: false,
+                callReady: false,
+                callEmitted: false,
+                resultEmitted: false,
+            };
+            tools.set(update.toolCallId, tracked);
+        }
+        if (tracked.resultEmitted)
+            return;
+        const tool = tracked.tool;
+        const terminal = tool.status === 'completed' || tool.status === 'failed';
+        if (update.title != null)
+            tool.title = update.title;
+        if (update.name != null)
+            tool.name = update.name;
+        if (update.kind != null)
+            tool.kind = update.kind;
+        if (update.status != null && !terminal)
+            tool.status = update.status;
+        if (update.rawInput !== undefined)
+            tool.rawInput = update.rawInput;
+        if (update.rawOutput !== undefined && (!terminal || tool.rawOutput === undefined))
+            tool.rawOutput = update.rawOutput;
+        if (update.content !== undefined)
+            tool.content = update.content ?? undefined;
+        if (update.locations !== undefined)
+            tool.locations = update.locations ?? undefined;
+        if (update._meta !== undefined)
+            tool._meta = update._meta === null ? undefined : { ...tool._meta, ...update._meta };
+        tracked.hasMetadata ||= update.title != null || toolName(tool) !== undefined;
+        tracked.callReady ||=
+            update.sessionUpdate === 'tool_call' || (toolName(tool) !== undefined && tool.rawInput !== undefined);
+        emitTool(tracked);
+    }
+    function flush() {
+        if (!live)
+            return;
+        closeMessage();
+        for (const tracked of tools.values())
+            emitTool(tracked, true);
+        batcher.close();
+    }
+    return {
+        canonicalToolCallId,
+        getTool(nativeId) {
+            const tracked = tools.get(nativeId);
+            return tracked?.hasMetadata ? tracked.tool : undefined;
+        },
+        beginLive(explicit) {
+            if (live || finished)
+                return;
+            baseline = explicit ? validTokens(explicit.inputTokens, explicit.outputTokens) : latest;
+            baselineCost = explicit ? (validCost(explicit.costUsd) ? explicit.costUsd : undefined) : latestCost;
+            latest = baseline;
+            latestCost = baselineCost;
+            live = true;
+        },
+        onUpdate({ update }) {
+            if (finished)
+                return;
+            if (update.sessionUpdate === 'usage_update') {
+                captureUsage(update);
+                return;
+            }
+            if (!live)
+                return;
+            switch (update.sessionUpdate) {
+                case 'agent_message_chunk':
+                case 'agent_thought_chunk': {
+                    if (update.content.type !== 'text')
+                        return;
+                    if (messageKind && messageKind !== update.sessionUpdate)
+                        closeMessage();
+                    const nextId = update.messageId
+                        ? scoped('message', update.messageId)
+                        : (messageId ?? scoped('anonymous-message', String(++messageSequence)));
+                    if (messageId && messageId !== nextId)
+                        closeMessage();
+                    messageId = nextId;
+                    messageKind = update.sessionUpdate;
+                    if (update.sessionUpdate === 'agent_thought_chunk') {
+                        batcher.close();
+                        batcher.push({ kind: 'message:thinking', messageId, text: update.content.text, streaming: true });
+                    }
+                    else {
+                        batcher.push({ kind: 'message:text', messageId, text: update.content.text, streaming: true });
+                        if (!brainstormEmitted) {
+                            const text = brainstormTail + update.content.text;
+                            if (text.includes(BRAINSTORM_COMPLETE)) {
+                                brainstormEmitted = true;
+                                batcher.push({ kind: 'session:brainstorm-complete' });
+                            }
+                            brainstormTail = text.slice(-(BRAINSTORM_COMPLETE.length - 1));
+                        }
+                    }
+                    return;
+                }
+                case 'tool_call':
+                case 'tool_call_update':
+                    closeMessage();
+                    mergeTool(update);
+                    return;
+                case 'plan': {
+                    closeMessage();
+                    const toolCallId = scoped('plan', String(++planSequence));
+                    batcher.push({
+                        kind: 'tool:call',
+                        messageId: '',
+                        toolCallId,
+                        name: 'TodoWrite',
+                        input: { todos: update.entries.map(({ content, status }) => ({ content, status })) },
+                    });
+                    batcher.push({ kind: 'tool:result', toolCallId, output: null, isError: false });
+                    return;
+                }
+                case 'notice':
+                    if (update.severity === 'error')
+                        batcher.push({ kind: 'error', category: 'other', message: update.description || update.title });
+                    return;
+                case 'compaction_update': {
+                    const previous = compactions.get(update.compactionId);
+                    if (previous === update.status || (previous && previous !== 'in_progress'))
+                        return;
+                    const compactionId = scoped('compaction', update.compactionId);
+                    if (update.status === 'in_progress') {
+                        compactions.set(update.compactionId, update.status);
+                        batcher.push({ kind: 'session:compacting', active: true, compactionId });
+                    }
+                    else if (['completed', 'failed', 'cancelled'].includes(update.status)) {
+                        compactions.set(update.compactionId, update.status);
+                        batcher.push({ kind: 'session:compacting', active: false, compactionId });
+                        if (update.status === 'completed')
+                            batcher.push({ kind: 'session:compacted', compactionId });
+                    }
+                    return;
+                }
+            }
+        },
+        finish(result) {
+            if (!live || finished)
+                return;
+            // Stable SDK responses are unchecked; native cumulative usage is not in PromptResponse's type.
+            const response = object(result);
+            const nativeUsage = object(response?.usage);
+            if (nativeUsage && ('inputTokens' in nativeUsage || 'outputTokens' in nativeUsage))
+                captureTokens(nativeUsage.inputTokens, nativeUsage.outputTokens);
+            flush();
+            finished = true;
+            if (baseline && latest && sawLiveTokens && !tokensReset) {
+                batcher.push({
+                    kind: 'usage',
+                    inputTokens: latest.inputTokens - baseline.inputTokens,
+                    outputTokens: latest.outputTokens - baseline.outputTokens,
+                    ...(baselineCost !== undefined && latestCost !== undefined && sawLiveCost && !costReset
+                        ? { costUsd: latestCost - baselineCost }
+                        : {}),
+                });
+            }
+            const stopReason = response?.stopReason;
+            if (stopReason === 'max_tokens' || stopReason === 'max_turn_requests' || stopReason === 'refusal') {
+                batcher.push({
+                    kind: 'error',
+                    category: 'other',
+                    message: `Vibe prompt stopped: ${stopReason}`,
+                    code: `acp_${stopReason}`,
+                });
+            }
+            else if (stopReason !== 'end_turn' && stopReason !== 'cancelled') {
+                batcher.push({ kind: 'error', category: 'parse_error', message: 'Invalid Vibe ACP prompt stop reason' });
+            }
+        },
+        flush,
+    };
+}