@minionry/minion 0.7.36

package/dist/server/engines/execution/engine-session.js

@@ -0,0 +1,380 @@
+// Copyright (c) 2025-present Minionry, Inc. All rights reserved.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createEngine } from '../factory.js';
+import { reportsNativeResume, supportsQuestions } from '../types.js';
+export function shouldRouteToEngine(engineId) {
+    return engineId !== 'claude-code';
+}
+class ActiveTurn {
+    callbacks;
+    done;
+    usageBase;
+    assistant = '';
+    thinking = '';
+    toolUseHistory = [];
+    stopReason;
+    fatalError;
+    heldError;
+    turnError;
+    lastToolSignature = '';
+    identicalToolCalls = 0;
+    toolErrorStreak = 0;
+    resolve;
+    settled = false;
+    constructor(callbacks, usageBase) {
+        this.callbacks = callbacks;
+        this.usageBase = usageBase;
+        this.done = new Promise((resolve) => {
+            this.resolve = resolve;
+        });
+    }
+    get failure() {
+        return this.fatalError ?? this.turnError;
+    }
+    get isSettled() {
+        return this.settled;
+    }
+    releaseHeldError() {
+        if (this.heldError === undefined)
+            return;
+        this.callbacks.outputCallback?.(this.heldError.output);
+        this.heldError = undefined;
+    }
+    settle() {
+        if (this.settled)
+            return;
+        this.settled = true;
+        this.resolve();
+    }
+    fail(failure) {
+        if (this.settled)
+            return;
+        this.fatalError = failure;
+        this.settle();
+    }
+}
+export class EngineSession {
+    engineId;
+    engine;
+    rawEmptyOutput;
+    pump = Promise.resolve();
+    active = null;
+    engineSessionId = '';
+    disposed = false;
+    terminalError = null;
+    streamClosed = false;
+    constructor(engine, engineId, resumeSessionId, sessionOptions) {
+        this.engine = engine;
+        this.engineId = engineId;
+        this.rawEmptyOutput = sessionOptions?.rawEmptyOutput ?? false;
+        if (resumeSessionId)
+            this.engineSessionId = resumeSessionId;
+    }
+    static async start(engineId, options, sessionOptions) {
+        const engine = createEngine(engineId);
+        try {
+            await engine.startSession(options);
+        }
+        catch (err) {
+            await engine.dispose().catch(() => { });
+            throw err;
+        }
+        const session = new EngineSession(engine, engineId, options.resumeSessionId, sessionOptions);
+        session.pump = session.runPump();
+        return session;
+    }
+    get sessionId() {
+        return this.engineSessionId;
+    }
+    get isAlive() {
+        return !this.disposed && this.terminalReason() === null;
+    }
+    get resumedNatively() {
+        return reportsNativeResume(this.engine) ? this.engine.resumedNatively : true;
+    }
+    async runTurn(prompt, attachments, callbacks) {
+        if (this.disposed)
+            throw new Error('EngineSession: runTurn called after dispose');
+        if (this.active)
+            throw new Error('EngineSession: a turn is already in flight');
+        const terminal = this.terminalReason();
+        if (terminal) {
+            const deadTurn = new ActiveTurn(callbacks, this.engine.getUsage());
+            deadTurn.fail(terminal);
+            return this.buildResult(deadTurn);
+        }
+        const turn = new ActiveTurn(callbacks, this.engine.getUsage());
+        this.active = turn;
+        try {
+            await this.engine.sendPrompt(prompt, attachments);
+            await turn.done;
+        }
+        catch (err) {
+            turn.fail({ message: err instanceof Error ? err.message : String(err) });
+        }
+        finally {
+            this.active = null;
+            turn.releaseHeldError();
+        }
+        return this.buildResult(turn);
+    }
+    async cancel() {
+        if (this.disposed)
+            return;
+        this.active?.settle();
+        await this.engine.cancel();
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        await this.engine.dispose();
+        await this.pump.catch(() => {
+        });
+        this.active?.settle();
+        this.active = null;
+    }
+    async runPump() {
+        for await (const event of this.engine) {
+            if (event.sessionId)
+                this.engineSessionId = event.sessionId;
+            this.dispatch(event);
+        }
+        this.streamClosed = true;
+        this.active?.fail(this.terminalError ?? { message: this.streamClosedMessage() });
+    }
+    terminalReason() {
+        if (this.terminalError)
+            return this.terminalError;
+        if (this.streamClosed)
+            return { message: this.streamClosedMessage() };
+        return null;
+    }
+    streamClosedMessage() {
+        return `The ${this.engineId} engine stopped before it produced any output.`;
+    }
+    dispatch(event) {
+        const turn = this.active;
+        if (!turn) {
+            if (event.kind === 'engine.error' && event.fatal) {
+                this.terminalError ??= { message: event.message, code: event.code };
+            }
+            return;
+        }
+        this.decideHeldError(turn, event);
+        switch (event.kind) {
+            case 'message.delta':
+                turn.assistant += event.text;
+                turn.callbacks.outputCallback?.(event.text);
+                break;
+            case 'message.thinking':
+                turn.thinking += event.text;
+                turn.callbacks.thinkingCallback?.(event.text);
+                break;
+            case 'tool.start':
+                turn.callbacks.toolUseCallback?.({ type: 'tool_start', toolName: event.toolName, toolId: event.toolCallId });
+                if (hasKeys(event.input)) {
+                    turn.callbacks.toolUseCallback?.({ type: 'tool_complete', toolName: event.toolName, toolId: event.toolCallId, completeInput: event.input });
+                }
+                break;
+            case 'tool.end':
+                turn.callbacks.toolUseCallback?.({ type: 'tool_result', toolName: event.toolName, toolId: event.toolCallId, result: event.result, isError: event.isError });
+                turn.toolUseHistory.push({
+                    toolName: event.toolName,
+                    toolId: event.toolCallId,
+                    toolInput: event.input,
+                    result: event.result,
+                    isError: event.isError,
+                    duration: event.durationMs,
+                });
+                this.guardAgainstToolLoop(turn, event);
+                break;
+            case 'usage.update':
+                turn.callbacks.tokenUsageCallback?.(deltaTokenUsage(turn.usageBase, event));
+                break;
+            case 'session.idle':
+                turn.stopReason = event.stopReason;
+                turn.settle();
+                break;
+            case 'engine.error':
+                this.handleEngineError(turn, event);
+                break;
+            case 'question.request':
+                this.handleQuestionRequest(event);
+                break;
+        }
+    }
+    decideHeldError(turn, event) {
+        if (!turn.heldError)
+            return;
+        if (event.kind === 'session.idle' && event.stopReason === 'error') {
+            turn.turnError = { message: turn.heldError.message, code: turn.heldError.code };
+            turn.heldError = undefined;
+            return;
+        }
+        turn.releaseHeldError();
+    }
+    handleEngineError(turn, event) {
+        if (event.fatal) {
+            turn.fatalError = { message: event.message, code: event.code };
+            this.terminalError ??= turn.fatalError;
+            turn.settle();
+            return;
+        }
+        const output = `\n[${this.engineId}] ${event.message}\n`;
+        if (turn.isSettled) {
+            turn.callbacks.outputCallback?.(output);
+        }
+        else {
+            turn.heldError = { message: event.message, code: event.code, output };
+        }
+    }
+    handleQuestionRequest(event) {
+        const engine = this.engine;
+        if (!supportsQuestions(engine))
+            return;
+        const ask = this.active?.callbacks.questionCallback;
+        if (!ask) {
+            void engine.rejectQuestion(event.requestId).catch(() => { });
+            return;
+        }
+        void ask({ requestId: event.requestId, questions: event.questions })
+            .then((answers) => answers
+            ? engine.answerQuestion(event.requestId, answers)
+            : engine.rejectQuestion(event.requestId))
+            .catch(() => engine.rejectQuestion(event.requestId).catch(() => { }));
+    }
+    guardAgainstToolLoop(turn, event) {
+        const signature = `${event.toolName}${stableStringify(event.input)}`;
+        if (signature === turn.lastToolSignature) {
+            turn.identicalToolCalls += 1;
+        }
+        else {
+            turn.lastToolSignature = signature;
+            turn.identicalToolCalls = 1;
+        }
+        turn.toolErrorStreak = event.isError ? turn.toolErrorStreak + 1 : 0;
+        const tooManyIdentical = turn.identicalToolCalls >= MAX_IDENTICAL_TOOL_CALLS;
+        const tooManyErrors = turn.toolErrorStreak >= MAX_TOOL_ERROR_STREAK;
+        if (!tooManyIdentical && !tooManyErrors)
+            return;
+        const reason = tooManyIdentical
+            ? `repeated the same '${event.toolName}' call ${turn.identicalToolCalls}× without progress`
+            : `${turn.toolErrorStreak} consecutive tool errors`;
+        turn.fail({ message: `Aborted: ${reason}.` });
+        void this.engine.cancel();
+    }
+    buildResult(turn) {
+        const after = this.engine.getUsage();
+        const base = turn.usageBase;
+        const delta = (cur, prev) => Math.max(0, cur - prev);
+        const out = delta(after.outputTokens, base.outputTokens);
+        const total = delta(after.inputTokens, base.inputTokens) +
+            out +
+            delta(after.cacheCreationTokens ?? 0, base.cacheCreationTokens ?? 0) +
+            delta(after.cacheReadTokens ?? 0, base.cacheReadTokens ?? 0);
+        return {
+            completed: !turn.failure,
+            needsHandoff: false,
+            totalTokens: total,
+            outputTokens: out > 0 ? out : undefined,
+            sessionId: this.engineSessionId || `${this.engineId}-session`,
+            claudeSessionId: this.engineSessionId || undefined,
+            error: turn.failure?.message,
+            ...(turn.failure?.code ? { errorCode: turn.failure.code } : {}),
+            assistantResponse: resolveAssistantText(turn, out, this.rawEmptyOutput),
+            thinkingOutput: turn.thinking || undefined,
+            toolUseHistory: turn.toolUseHistory.length > 0 ? turn.toolUseHistory : undefined,
+            stopReason: turn.stopReason,
+        };
+    }
+}
+export async function runEngineOnce(options) {
+    const startOptions = {
+        workingDir: options.workingDir,
+        ...(options.model ? { model: options.model } : {}),
+        ...(options.effortLevel ? { effortLevel: options.effortLevel } : {}),
+        ...(options.fastMode ? { fastMode: options.fastMode } : {}),
+        ...(options.systemPrompt ? { systemPrompt: options.systemPrompt } : {}),
+        ...(options.resumeSessionId ? { resumeSessionId: options.resumeSessionId } : {}),
+        ...(options.disallowedTools ? { disallowedTools: options.disallowedTools } : {}),
+        ...(options.deployMode ? { deployMode: options.deployMode } : {}),
+        ...(options.extraEnv ? { extraEnv: options.extraEnv } : {}),
+        ...(options.browserMcp ? { browserMcp: options.browserMcp } : {}),
+    };
+    const session = await EngineSession.start(options.engineId, startOptions, {
+        rawEmptyOutput: options.rawEmptyOutput ?? false,
+    });
+    const onAbort = () => {
+        void session.cancel();
+    };
+    if (options.abortSignal) {
+        if (options.abortSignal.aborted)
+            void session.cancel();
+        else
+            options.abortSignal.addEventListener('abort', onAbort, { once: true });
+    }
+    try {
+        return await session.runTurn(options.prompt, toPromptAttachments(options.imageAttachments), options.callbacks);
+    }
+    finally {
+        options.abortSignal?.removeEventListener('abort', onAbort);
+        await session.dispose();
+    }
+}
+export function toPromptAttachments(images) {
+    if (!images || images.length === 0)
+        return undefined;
+    return images
+        .filter((a) => a.isImage && a.content)
+        .map((a) => ({
+        fileName: a.fileName,
+        filePath: a.filePath,
+        base64Content: a.content,
+        mimeType: a.mimeType,
+        isImage: true,
+    }));
+}
+function hasKeys(input) {
+    return !!input && Object.keys(input).length > 0;
+}
+const MAX_IDENTICAL_TOOL_CALLS = 3;
+const MAX_TOOL_ERROR_STREAK = 5;
+export const EMPTY_OUTPUT_NOTICE = '(No visible answer was returned — the model may have produced only hidden reasoning, or the provider dropped the response text. Try rephrasing, or turn off reasoning for this model.)';
+function resolveAssistantText(turn, outputTokens, rawEmptyOutput) {
+    if (turn.assistant)
+        return turn.assistant;
+    if (turn.thinking)
+        return stripThinkTags(turn.thinking);
+    if (!rawEmptyOutput && !turn.failure && outputTokens > 0)
+        return EMPTY_OUTPUT_NOTICE;
+    return undefined;
+}
+function stripThinkTags(text) {
+    return text.replace(/<\/?think>/gi, '').trim();
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value) ?? 'null';
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(',')}]`;
+    }
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(',')}}`;
+}
+function deltaTokenUsage(base, event) {
+    const delta = (cur, prev) => Math.max(0, cur - prev);
+    const inputTokens = delta(event.inputTokens, base.inputTokens);
+    const cacheCreationTokens = delta(event.cacheCreationTokens ?? 0, base.cacheCreationTokens ?? 0);
+    const cacheReadTokens = delta(event.cacheReadTokens ?? 0, base.cacheReadTokens ?? 0);
+    return {
+        inputTokens,
+        outputTokens: delta(event.outputTokens, base.outputTokens),
+        cacheCreationTokens,
+        cacheReadTokens,
+        currentTurnInputTokens: inputTokens + cacheCreationTokens + cacheReadTokens,
+        isFinal: false,
+    };
+}

package/dist/server/engines/factory.js

@@ -0,0 +1,42 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { ClaudeCodeEngine } from './claude/ClaudeCodeEngine.js';
+import { CodexEngine } from './codex/CodexEngine.js';
+import { resolveCodexCommand } from './codex/codex-provision.js';
+import { resolveModelProfile } from './credentials/model-profiles.js';
+import { ProviderCredentialStore } from './credentials/provider-credentials.js';
+import { HermesEngine } from './hermes/HermesEngine.js';
+import { createHermesAuth } from './hermes/hermes-auth.js';
+import { planHermesAppRunGatewayHome, planHermesGatewayHome, planHermesProfileGatewayHome, provisionHermesGatewayHome, } from './hermes/hermes-gateway-home.js';
+function provisionAppRunGatewayHome(model, appRun) {
+    const owned = resolveModelProfile(model);
+    const plan = owned?.profile.engine === 'hermes'
+        ? planHermesAppRunGatewayHome(owned.profile, owned.apiKey, appRun)
+        : null;
+    return plan ? provisionHermesGatewayHome(plan) : null;
+}
+export function createEngine(engineId) {
+    switch (engineId) {
+        case 'claude-code':
+            return new ClaudeCodeEngine();
+        case 'codex':
+            return new CodexEngine({ resolveCommand: () => resolveCodexCommand() });
+        case 'hermes':
+            return new HermesEngine({
+                auth: createHermesAuth(),
+                provisionGatewayHome: (model, browserMcp, appRun) => {
+                    if (appRun)
+                        return provisionAppRunGatewayHome(model, appRun);
+                    const profile = resolveModelProfile(model);
+                    const plan = profile
+                        ? planHermesProfileGatewayHome(profile.profile, profile.apiKey, browserMcp)
+                        : planHermesGatewayHome(model, new ProviderCredentialStore(), process.env, browserMcp);
+                    return plan ? provisionHermesGatewayHome(plan) : null;
+                },
+            });
+        default: {
+            const exhaustive = engineId;
+            throw new Error(`Unknown engine id: ${String(exhaustive)}`);
+        }
+    }
+}