@loicngr/kobo 2.1.28 → 2.1.30

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,
+    };
+}

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

@@ -0,0 +1,35 @@
+import { resolve } from 'node:path';
+import { buildKoboLaunchInstructions, getKoboPromptCapabilities, } from '../../../../../shared/launch-instructions.js';
+import { assertMistralSelection, MISTRAL_MODES } from './configuration.js';
+export function buildMistralOptions(options) {
+    if (options.resumeFromEngineSessionId !== undefined && !options.resumeFromEngineSessionId.trim())
+        throw new Error('Mistral Vibe requires a nonempty saved session identity');
+    const permissionMode = options.agentPermissionMode ?? 'interactive';
+    const capabilities = getKoboPromptCapabilities(options.mcpServers?.find((server) => server.name === 'kobo-tasks')?.env);
+    if (permissionMode === 'plan' || options.readOnly || capabilities.handoff)
+        throw new Error('Mistral Vibe does not support Plan or read-only launches');
+    assertMistralSelection(options.model, 'model');
+    assertMistralSelection(options.effort, 'thinking');
+    if (!Object.hasOwn(MISTRAL_MODES, permissionMode))
+        throw new Error('Unsupported Mistral Vibe permission mode');
+    const modeId = MISTRAL_MODES[permissionMode];
+    const koboInstructions = buildKoboLaunchInstructions({
+        engine: 'mistral-vibe',
+        permissionMode,
+        autoLoop: options.autoLoop,
+        ...capabilities,
+    });
+    return {
+        cwd: resolve(options.workingDir),
+        modeId,
+        koboInstructions,
+        mcpServers: (options.mcpServers ?? []).map((server) => ({
+            name: server.name,
+            command: server.command,
+            args: [...server.args],
+            env: Object.entries(server.env).map(([name, value]) => ({ name, value })),
+        })),
+        prompt: [{ type: 'text', text: `${koboInstructions.promptPrefix}\n\n${options.prompt}` }],
+        env: { ...process.env, ...options.env },
+    };
+}

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

@@ -0,0 +1,278 @@
+import { isOperationApprovalAvailable } from '../../../workspace-permission-policy-service.js';
+import { PendingUserInputValidationError } from '../types.js';
+function record(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function onlyKeys(value, keys) {
+    return Object.keys(value).every((key) => keys.includes(key));
+}
+function text(value, max = 4000) {
+    return typeof value === 'string' && value.length <= max;
+}
+function bound(value, fallback, ceiling) {
+    if (value == null)
+        return fallback;
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && value <= ceiling ? value : undefined;
+}
+function choices(schema, titledKey) {
+    if (schema.enum != null && schema[titledKey] != null)
+        return undefined;
+    let options;
+    if (Array.isArray(schema.enum) && schema.enum.every((value) => text(value, 2000))) {
+        options = schema.enum.map((label) => ({ label }));
+    }
+    else if (Array.isArray(schema[titledKey])) {
+        const values = schema[titledKey];
+        if (!values.every((v) => record(v) &&
+            onlyKeys(v, ['const', 'title', 'description', '_meta']) &&
+            text(v.const, 2000) &&
+            text(v.title, 2000) &&
+            (v.description == null || text(v.description))))
+            return undefined;
+        options = values.map((v) => ({ label: v.const, description: (v.description ?? v.title) }));
+    }
+    else
+        return undefined;
+    if (!options.length || options.length > 32 || new Set(options.map((o) => o.label)).size !== options.length)
+        return undefined;
+    return options;
+}
+function formFields(schema) {
+    if (!record(schema) ||
+        !onlyKeys(schema, ['type', 'title', 'description', 'properties', 'required', '_meta']) ||
+        (schema.type != null && schema.type !== 'object') ||
+        !record(schema.properties))
+        return undefined;
+    const entries = Object.entries(schema.properties);
+    if (!entries.length || entries.length > 20)
+        return undefined;
+    const required = schema.required ?? [];
+    if (!Array.isArray(required) ||
+        required.some((key) => typeof key !== 'string' || !Object.hasOwn(schema.properties, key)) ||
+        new Set(required).size !== required.length)
+        return undefined;
+    const fields = [];
+    for (const [id, property] of entries) {
+        if (!id ||
+            !text(id, 200) ||
+            !record(property) ||
+            (property.title != null && !text(property.title)) ||
+            (property.description != null && !text(property.description)))
+            return undefined;
+        const multiSelect = property.type === 'array';
+        if (property.type !== 'string' && !multiSelect)
+            return undefined;
+        if (!onlyKeys(property, multiSelect
+            ? ['type', 'title', 'description', 'items', 'minItems', 'maxItems', 'default', '_meta']
+            : [
+                'type',
+                'title',
+                'description',
+                'minLength',
+                'maxLength',
+                'enum',
+                'oneOf',
+                'default',
+                'pattern',
+                'format',
+                '_meta',
+            ]))
+            return undefined;
+        // Pattern/format constraints need native validation support before they can be rendered safely.
+        if (property.pattern != null || property.format != null)
+            return undefined;
+        let options = [];
+        if (multiSelect) {
+            if (!record(property.items) ||
+                !onlyKeys(property.items, ['type', 'enum', 'anyOf', '_meta']) ||
+                (property.items.type != null && property.items.type !== 'string'))
+                return undefined;
+            const parsed = choices(property.items, 'anyOf');
+            if (!parsed)
+                return undefined;
+            options = parsed;
+        }
+        else if (property.enum != null || property.oneOf != null) {
+            const parsed = choices(property, 'oneOf');
+            if (!parsed)
+                return undefined;
+            options = parsed;
+        }
+        const min = bound(multiSelect ? property.minItems : property.minLength, 0, multiSelect ? options.length : 10000);
+        const max = bound(multiSelect ? property.maxItems : property.maxLength, multiSelect ? options.length : 10000, multiSelect ? options.length : 10000);
+        if (min === undefined || max === undefined || min > max)
+            return undefined;
+        fields.push({
+            id,
+            question: (property.description ?? property.title ?? id),
+            ...(property.title ? { header: property.title } : {}),
+            options,
+            required: required.includes(id),
+            freeText: !multiSelect && !options.length,
+            multiSelect,
+            isOther: false,
+            min,
+            max,
+        });
+    }
+    return fields;
+}
+function formAnswer(fields, response) {
+    if (!record(response.answers) || (response.selections !== undefined && !record(response.selections)))
+        return undefined;
+    if (Object.keys(response.answers).some((id) => !fields.some((field) => field.id === id)) ||
+        Object.keys(response.selections ?? {}).some((id) => !fields.some((field) => field.id === id && field.multiSelect)))
+        return undefined;
+    const content = [];
+    for (const field of fields) {
+        const source = field.multiSelect ? response.selections : response.answers;
+        if (!source || !Object.hasOwn(source, field.id)) {
+            if (field.required || Object.hasOwn(response.answers, field.id))
+                return undefined;
+            continue;
+        }
+        const value = source[field.id];
+        if (field.multiSelect) {
+            if (!Array.isArray(value) ||
+                value.length < field.min ||
+                value.length > field.max ||
+                new Set(value).size !== value.length ||
+                value.some((v) => !text(v, 2000) || !field.options.some((o) => o.label === v)))
+                return undefined;
+            content.push([field.id, [...value]]);
+        }
+        else {
+            if (!text(value, field.max) ||
+                value.length < field.min ||
+                (!field.freeText && !field.options.some((o) => o.label === value)))
+                return undefined;
+            content.push([field.id, value]);
+        }
+    }
+    return { action: 'accept', content: Object.fromEntries(content) };
+}
+export function createMistralServerRequests(args) {
+    const pending = new Map();
+    const seen = new Set();
+    let closed = false;
+    function wait(key, signal, cancelled, answer, event) {
+        return new Promise((resolve) => {
+            function settle(result) {
+                if (!pending.delete(key))
+                    return;
+                signal.removeEventListener('abort', cancel);
+                resolve(result);
+                args.onPendingChange?.(pending.size);
+            }
+            const cancel = () => settle(cancelled);
+            pending.set(key, {
+                cancel,
+                answer: (response) => {
+                    const result = answer(response);
+                    if (result === undefined)
+                        throw new PendingUserInputValidationError();
+                    settle(result);
+                    return true;
+                },
+            });
+            seen.add(key);
+            signal.addEventListener('abort', cancel, { once: true });
+            args.onPendingChange?.(pending.size);
+            if (pending.has(key))
+                args.emit(event);
+        });
+    }
+    function unavailable(key, signal) {
+        return closed || signal.aborted || seen.has(key) || pending.size >= 32 || seen.size >= 4096;
+    }
+    return {
+        requestPermission({ params, signal }) {
+            const cancelled = { outcome: { outcome: 'cancelled' } };
+            if (closed || signal.aborted || args.readOnly || params.sessionId !== args.sessionId)
+                return cancelled;
+            const tool = args.getTool(params.toolCall.toolCallId);
+            const toolName = tool?._meta?.tool_name;
+            if (!tool || typeof toolName !== 'string' || !toolName.trim() || toolName.length > 200)
+                return cancelled;
+            const key = args.canonicalToolCallId(params.toolCall.toolCallId);
+            if (unavailable(key, signal))
+                return cancelled;
+            const offered = params.options;
+            if (!offered.length ||
+                offered.some((option) => !option.optionId) ||
+                new Set(offered.map((option) => option.optionId)).size !== offered.length)
+                return cancelled;
+            const allow = offered.find((option) => option.kind === 'allow_once');
+            const deny = offered.find((option) => option.kind === 'reject_once');
+            if (!allow || !deny)
+                return cancelled;
+            const payload = {
+                rawInput: tool.rawInput ?? null,
+                effectKind: tool._meta?.effect_kind ?? null,
+                kind: tool.kind ?? null,
+                operationApprovalAvailable: false,
+            };
+            payload.operationApprovalAvailable = isOperationApprovalAvailable({
+                engine: 'mistral-vibe',
+                toolName,
+                payload: { ...payload, operationApprovalAvailable: true },
+            });
+            const selected = (optionId) => ({ outcome: { outcome: 'selected', optionId } });
+            const approved = args.autoApprove?.(toolName, payload);
+            if (closed || signal.aborted)
+                return cancelled;
+            if (approved) {
+                seen.add(key);
+                return selected(allow.optionId);
+            }
+            return wait(key, signal, cancelled, (response) => response.kind === 'permission-allow'
+                ? selected(allow.optionId)
+                : response.kind === 'permission-deny'
+                    ? selected(deny.optionId)
+                    : undefined, { kind: 'session:user-input-requested', requestKind: 'permission', toolCallId: key, toolName, payload });
+        },
+        createElicitation({ params, signal, requestId }) {
+            if (closed || signal.aborted || args.readOnly)
+                return { action: 'cancel' };
+            if (params.mode !== 'form' ||
+                !('sessionId' in params) ||
+                params.sessionId !== args.sessionId ||
+                !text(params.message))
+                return { action: 'decline' };
+            const fields = formFields(params.requestedSchema);
+            if (!fields)
+                return { action: 'decline' };
+            const nativeId = typeof params.toolCallId === 'string' ? params.toolCallId : '';
+            const key = `${args.canonicalToolCallId(nativeId)}:elicitation:${typeof requestId}:${encodeURIComponent(String(requestId))}`;
+            if (unavailable(key, signal))
+                return { action: 'decline' };
+            return wait(key, signal, { action: 'cancel' }, (response) => response.kind === 'question-cancel'
+                ? { action: 'cancel' }
+                : response.kind === 'question'
+                    ? formAnswer(fields, response)
+                    : undefined, {
+                kind: 'session:user-input-requested',
+                requestKind: 'question',
+                toolCallId: key,
+                toolName: 'AskUserQuestion',
+                payload: {
+                    questions: fields.map(({ min, max, ...field }) => ({
+                        ...field,
+                        ...(field.multiSelect ? { minItems: min, maxItems: max } : { minLength: min, maxLength: max }),
+                    })),
+                },
+            });
+        },
+        hasPendingUserInput(toolCallId) {
+            return pending.has(toolCallId);
+        },
+        resolvePendingUserInput(toolCallId, response) {
+            return pending.get(toolCallId)?.answer(response) ?? false;
+        },
+        cancelAll() {
+            closed = true;
+            for (const entry of pending.values())
+                entry.cancel();
+        },
+    };
+}