@jungjaehoon/mama-os 0.53.1 → 0.58.0

package/dist/agent/cline-cli-adapter.js

@@ -1,1042 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClineCLIAdapter = void 0;
-exports.resolveClineDataDir = resolveClineDataDir;
-exports.hasPersistedClineCredential = hasPersistedClineCredential;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const node_url_1 = require("node:url");
-const node_crypto_1 = require("node:crypto");
-const node_events_1 = require("node:events");
-const node_os_1 = require("node:os");
-const model_runner_js_1 = require("./model-runner.js");
-const cline_native_tool_policy_js_1 = require("./cline-native-tool-policy.js");
-const completed_terminal_result_js_1 = require("./code-act/completed-terminal-result.js");
-const types_js_1 = require("./types.js");
-const CLINE_CODE_ACT_TOOL_NAME = 'mcp__code-act__code_act';
-const MAMA_CODE_ACT_TOOL_NAME = 'code_act';
-const CLINE_MUTATION_SETTLEMENT_GRACE_MS = 5_250;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function stringValue(record, key) {
-    const value = record[key];
-    return typeof value === 'string' ? value : undefined;
-}
-function numberValue(record, key) {
-    const value = record[key];
-    return typeof value === 'number' ? value : undefined;
-}
-function normalizeToolOutput(value) {
-    if (typeof value === 'string') {
-        return value;
-    }
-    if (value === undefined) {
-        return '';
-    }
-    return JSON.stringify(value);
-}
-function classifyFailure(message) {
-    const normalized = message.toLowerCase();
-    if (/quota|rate.?limit|\b429\b/.test(normalized)) {
-        return 'rate_limit';
-    }
-    if (/unauthorized|authentication|invalid api key|credentials?|\b401\b|\b403\b/.test(normalized)) {
-        return 'auth_failure';
-    }
-    if (/context.{0,20}(length|window|overflow)|too many tokens/.test(normalized)) {
-        return 'context_overflow';
-    }
-    if (/timed? out|timeout/.test(normalized)) {
-        return 'timeout';
-    }
-    return 'crash';
-}
-function resolveClineDataDir(dataDir) {
-    if (dataDir === '~') {
-        return (0, node_os_1.homedir)();
-    }
-    if (dataDir.startsWith('~/')) {
-        return (0, node_path_1.resolve)((0, node_os_1.homedir)(), dataDir.slice(2));
-    }
-    return (0, node_path_1.resolve)(dataDir);
-}
-function safeProviderFailure(rawText, finishReason) {
-    const code = classifyFailure(rawText || finishReason);
-    let providerCode;
-    let providerMessage = '';
-    try {
-        const parsed = JSON.parse(rawText);
-        if (isRecord(parsed) && isRecord(parsed.error)) {
-            providerCode = stringValue(parsed.error, 'code')
-                ?.replace(/[^A-Za-z0-9_.-]/g, '')
-                .slice(0, 64);
-            providerMessage = stringValue(parsed.error, 'message') ?? '';
-        }
-    }
-    catch {
-        providerMessage = rawText;
-    }
-    const reason = finishReason.replace(/[^A-Za-z0-9_.-]/g, '').slice(0, 32) || 'unknown';
-    const suffix = providerCode ? `, provider=${providerCode}` : '';
-    if (code === 'rate_limit') {
-        const retryHint = providerMessage.match(/try again in\s+\d+\s*(?:days?|hours?|minutes?|seconds?|[dhms])(?:\s+\d+\s*(?:days?|hours?|minutes?|seconds?|[dhms])){0,3}/i)?.[0];
-        return {
-            code,
-            message: `Cline Hub run failed (rate_limit${suffix}): Daily free limit reached${retryHint ? `. ${retryHint}` : ''}`.slice(0, 320),
-        };
-    }
-    if (code === 'auth_failure') {
-        return {
-            code,
-            message: `Cline Hub authentication failed${suffix}. Run: cline auth cline`.slice(0, 320),
-        };
-    }
-    const label = code === 'context_overflow'
-        ? 'context limit exceeded'
-        : code === 'timeout'
-            ? 'request timed out'
-            : `run ended with finish reason ${reason}`;
-    return { code, message: `Cline Hub ${label}${suffix}`.slice(0, 320) };
-}
-function executableCandidates(command) {
-    if ((0, node_path_1.isAbsolute)(command) || command.includes('/')) {
-        return [(0, node_path_1.resolve)(command)];
-    }
-    const pathEntries = (process.env.PATH ?? '').split(node_path_1.delimiter).filter(Boolean);
-    const suffixes = process.platform === 'win32' ? ['', '.cmd', '.exe', '.bat'] : [''];
-    return pathEntries.flatMap((entry) => suffixes.map((suffix) => (0, node_path_1.join)(entry, `${command}${suffix}`)));
-}
-function resolveClineWrapper(command) {
-    for (const candidate of executableCandidates(command)) {
-        try {
-            (0, node_fs_1.accessSync)(candidate, node_fs_1.constants.X_OK);
-            return (0, node_fs_1.realpathSync)(candidate);
-        }
-        catch {
-            // Continue through PATH candidates.
-        }
-    }
-    throw new Error(`Cline CLI executable not found: ${command}`);
-}
-function resolveClineSdkEntry(wrapperPath) {
-    let current = (0, node_path_1.dirname)(wrapperPath);
-    for (let depth = 0; depth < 8; depth += 1) {
-        const candidate = (0, node_path_1.join)(current, 'node_modules', '@cline', 'core', 'dist', 'index.js');
-        if ((0, node_fs_1.existsSync)(candidate)) {
-            return candidate;
-        }
-        const parent = (0, node_path_1.dirname)(current);
-        if (parent === current) {
-            break;
-        }
-        current = parent;
-    }
-    throw new Error(`The installed Cline CLI does not include its companion @cline/core runtime: ${wrapperPath}`);
-}
-function validateImportedSdk(value) {
-    if (!isRecord(value)) {
-        throw new Error('Cline companion SDK did not export an object');
-    }
-    const clineCore = value.ClineCore;
-    const providerManager = value.ProviderSettingsManager;
-    const clineCoreCreate = (typeof clineCore === 'function' || isRecord(clineCore)) &&
-        typeof clineCore.create === 'function';
-    if (!clineCoreCreate ||
-        typeof providerManager !== 'function' ||
-        typeof value.getPersistedProviderApiKey !== 'function' ||
-        typeof value.createTool !== 'function') {
-        throw new Error('Cline companion SDK is missing the Hub session API required by MAMA');
-    }
-    return value;
-}
-async function hasPersistedClineCredential(options = {}) {
-    const wrapperPath = resolveClineWrapper(options.command ?? process.env.MAMA_CLINE_COMMAND ?? process.env.CLINE_COMMAND ?? 'cline');
-    const sdkEntry = resolveClineSdkEntry(wrapperPath);
-    const imported = await import((0, node_url_1.pathToFileURL)(sdkEntry).href);
-    const sdk = validateImportedSdk(imported);
-    const dataDir = options.dataDir ? resolveClineDataDir(options.dataDir) : undefined;
-    const manager = new sdk.ProviderSettingsManager(dataDir ? { dataDir } : undefined);
-    const provider = options.provider ?? 'cline';
-    return Boolean(sdk.getPersistedProviderApiKey(provider, manager.getProviderSettings(provider)));
-}
-const defaultRuntimeFactory = async (input) => {
-    const wrapperPath = resolveClineWrapper(input.command);
-    const sdkEntry = resolveClineSdkEntry(wrapperPath);
-    if (input.dataDir) {
-        const requestedDataDir = resolveClineDataDir(input.dataDir);
-        const existingDataDir = process.env.CLINE_DATA_DIR?.trim();
-        if (existingDataDir && resolveClineDataDir(existingDataDir) !== requestedDataDir) {
-            throw new Error(`Cline Hub data directory is already bound to ${existingDataDir}; cannot switch to ${input.dataDir}`);
-        }
-        process.env.CLINE_DATA_DIR = requestedDataDir;
-    }
-    process.env.CLINE_WRAPPER_PATH = wrapperPath;
-    const imported = await import((0, node_url_1.pathToFileURL)(sdkEntry).href);
-    const sdk = validateImportedSdk(imported);
-    const providerManager = new sdk.ProviderSettingsManager(input.dataDir ? { dataDir: resolveClineDataDir(input.dataDir) } : undefined);
-    const providerSettings = providerManager.getProviderSettings(input.provider);
-    const apiKey = sdk.getPersistedProviderApiKey(input.provider, providerSettings);
-    const client = await sdk.ClineCore.create({
-        clientName: 'mama-os',
-        backendMode: 'hub',
-        hub: {
-            cwd: input.cwd,
-            workspaceRoot: input.cwd,
-            clientType: 'mama-os',
-            displayName: 'MAMA OS',
-            strategy: 'require-hub',
-        },
-    });
-    return {
-        client,
-        source: sdk.SessionSource?.CORE ?? 'core',
-        apiKey,
-        createTool: (definition) => sdk.createTool(definition),
-    };
-};
-function parseAgentResult(value) {
-    if (!isRecord(value)) {
-        throw new Error('Cline Hub returned no agent result');
-    }
-    const usage = isRecord(value.usage) ? value.usage : undefined;
-    return {
-        text: stringValue(value, 'text') ?? '',
-        finishReason: stringValue(value, 'finishReason') ?? 'unknown',
-        durationMs: numberValue(value, 'durationMs'),
-        usage: usage
-            ? {
-                inputTokens: numberValue(usage, 'inputTokens'),
-                outputTokens: numberValue(usage, 'outputTokens'),
-                cacheReadTokens: numberValue(usage, 'cacheReadTokens'),
-                cacheWriteTokens: numberValue(usage, 'cacheWriteTokens'),
-                totalCost: numberValue(usage, 'totalCost'),
-            }
-            : undefined,
-    };
-}
-function toolFingerprint(bridge, allowedTools, disallowedTools, allowSpawnAgent, allowAgentTeams) {
-    return JSON.stringify({
-        projectedTools: (bridge?.tools ?? []).map((tool) => ({
-            name: tool.name,
-            description: tool.description,
-            inputSchema: tool.inputSchema,
-        })),
-        allowedTools,
-        disallowedTools,
-        allowSpawnAgent,
-        allowAgentTeams,
-    });
-}
-function buildToolPolicies(bridge, allowedTools, disallowedTools) {
-    const allowAll = allowedTools.includes('*');
-    const policies = {
-        '*': { enabled: allowAll, autoApprove: allowAll },
-    };
-    if (!allowAll) {
-        for (const tool of allowedTools) {
-            policies[tool] = { enabled: true, autoApprove: true };
-        }
-    }
-    for (const tool of disallowedTools) {
-        policies[tool] = { enabled: false, autoApprove: false };
-    }
-    for (const definition of bridge?.tools ?? []) {
-        const name = definition.name === MAMA_CODE_ACT_TOOL_NAME ? CLINE_CODE_ACT_TOOL_NAME : definition.name;
-        policies[name] = { enabled: true, autoApprove: true };
-    }
-    return policies;
-}
-function combineSignals(...signals) {
-    const present = signals.filter((signal) => signal !== undefined);
-    if (present.length === 0) {
-        return new AbortController().signal;
-    }
-    return present.length === 1 ? present[0] : AbortSignal.any(present);
-}
-function abortError(signal) {
-    return signal.reason instanceof Error
-        ? signal.reason
-        : new model_runner_js_1.ModelRunnerError('Cline Hub request was aborted', 'unknown', false);
-}
-function raceWithAbort(operation, signal) {
-    if (signal.aborted) {
-        return Promise.reject(abortError(signal));
-    }
-    return new Promise((resolvePromise, rejectPromise) => {
-        const onAbort = () => rejectPromise(abortError(signal));
-        signal.addEventListener('abort', onAbort, { once: true });
-        operation.then((value) => {
-            signal.removeEventListener('abort', onAbort);
-            resolvePromise(value);
-        }, (error) => {
-            signal.removeEventListener('abort', onAbort);
-            rejectPromise(error);
-        });
-    });
-}
-class ClineCLIAdapter extends node_events_1.EventEmitter {
-    backendType = 'cline';
-    /** No native subagent primitive and no spawn observation path. */
-    supportsNativeSubagents = false;
-    options;
-    runtimeFactory;
-    sessions = new Map();
-    stableRoutes = new Map();
-    routesRequiringRebuild = new Set();
-    routeTails = new Map();
-    activeRoutes = new Set();
-    sessionLifecycleTail = Promise.resolve();
-    runtimePromise = null;
-    disposedRuntimes = new WeakSet();
-    runtimeWaiters = 0;
-    sessionId;
-    systemPrompt;
-    requestCount = 0;
-    failureCount = 0;
-    totalLatencyMs = 0;
-    lastRequestAt = null;
-    stopped = false;
-    maxSessions;
-    sessionTtlMs;
-    constructor(options = {}) {
-        super();
-        this.options = {
-            ...options,
-            command: options.command ?? process.env.MAMA_CLINE_COMMAND ?? process.env.CLINE_COMMAND,
-        };
-        this.runtimeFactory = options.runtimeFactory ?? defaultRuntimeFactory;
-        this.sessionId = options.sessionId ?? 'cline';
-        this.systemPrompt = options.systemPrompt ?? '';
-        this.maxSessions = Math.max(1, options.maxSessions ?? 100);
-        this.sessionTtlMs = Math.max(1, options.sessionTtlMs ?? 1_800_000);
-    }
-    async prompt(content, callbacks, promptOptions) {
-        const startedAt = Date.now();
-        const routeId = promptOptions?.sessionId ?? promptOptions?.sessionKey ?? this.sessionId;
-        const stableRouteId = promptOptions?.sessionKey ?? routeId;
-        const timeoutMs = promptOptions?.requestTimeout ?? this.options.requestTimeout ?? 600_000;
-        const deadlineController = new AbortController();
-        let lockAcquired = false;
-        const timeoutHandle = setTimeout(() => {
-            const error = new model_runner_js_1.ModelRunnerError(`Cline Hub request timed out after ${timeoutMs}ms`, 'timeout', true);
-            deadlineController.abort(error);
-            if (lockAcquired) {
-                void this.abortRoute(routeId, error);
-            }
-        }, timeoutMs);
-        timeoutHandle.unref();
-        this.requestCount += 1;
-        this.lastRequestAt = startedAt;
-        try {
-            return await this.withRouteLock(stableRouteId, deadlineController.signal, () => {
-                lockAcquired = true;
-                this.activeRoutes.add(routeId);
-            }, async () => {
-                try {
-                    return await this.runHubPrompt(routeId, stableRouteId, content, callbacks, promptOptions, deadlineController.signal, timeoutMs);
-                }
-                finally {
-                    this.activeRoutes.delete(routeId);
-                }
-            });
-        }
-        catch (error) {
-            this.failureCount += 1;
-            const normalized = this.normalizeError(error);
-            if (lockAcquired && normalized instanceof model_runner_js_1.ModelRunnerError && normalized.code === 'timeout') {
-                await this.quarantineRoute(routeId);
-            }
-            callbacks?.onError?.(normalized);
-            throw normalized;
-        }
-        finally {
-            clearTimeout(timeoutHandle);
-            this.totalLatencyMs += Date.now() - startedAt;
-            if (this.routeTails.size === 0) {
-                this.emit('idle');
-            }
-        }
-    }
-    async withRouteLock(routeId, signal, onAcquired, run) {
-        const previous = this.routeTails.get(routeId) ?? Promise.resolve();
-        let acquired = false;
-        const current = previous
-            .catch(() => undefined)
-            .then(async () => {
-            if (signal.aborted) {
-                throw signal.reason instanceof Error
-                    ? signal.reason
-                    : new model_runner_js_1.ModelRunnerError('Cline Hub request was aborted', 'unknown');
-            }
-            acquired = true;
-            onAcquired();
-            return await run();
-        });
-        const tail = current.then(() => undefined, () => undefined);
-        this.routeTails.set(routeId, tail);
-        void tail.then(() => {
-            if (this.routeTails.get(routeId) === tail) {
-                this.routeTails.delete(routeId);
-            }
-        });
-        return await new Promise((resolvePromise, rejectPromise) => {
-            const onAbort = () => {
-                if (!acquired) {
-                    rejectPromise(abortError(signal));
-                }
-            };
-            signal.addEventListener('abort', onAbort, { once: true });
-            current.then((value) => {
-                signal.removeEventListener('abort', onAbort);
-                resolvePromise(value);
-            }, (error) => {
-                signal.removeEventListener('abort', onAbort);
-                rejectPromise(error);
-            });
-        });
-    }
-    async withSessionLifecycleLock(signal, run) {
-        const current = this.sessionLifecycleTail
-            .catch(() => undefined)
-            .then(async () => {
-            if (signal.aborted) {
-                throw abortError(signal);
-            }
-            return await run();
-        });
-        this.sessionLifecycleTail = current.then(() => undefined, () => undefined);
-        return await raceWithAbort(current, signal);
-    }
-    async getRuntime(signal) {
-        if (this.stopped) {
-            throw new model_runner_js_1.ModelRunnerError('Cline Hub adapter is stopped', 'crash', false);
-        }
-        if (!this.runtimePromise) {
-            const pending = this.runtimeFactory({
-                command: this.options.command ?? 'cline',
-                cwd: this.options.cwd ?? process.cwd(),
-                dataDir: this.options.dataDir,
-                provider: this.options.provider ?? 'cline',
-            });
-            this.runtimePromise = pending;
-            void pending.catch(() => {
-                if (this.runtimePromise === pending) {
-                    this.runtimePromise = null;
-                }
-            });
-        }
-        const pending = this.runtimePromise;
-        this.runtimeWaiters += 1;
-        try {
-            const runtime = await raceWithAbort(pending, signal);
-            if (this.stopped) {
-                void this.disposeRuntimeOnce(runtime, 'mama_shutdown').catch(() => undefined);
-                throw new model_runner_js_1.ModelRunnerError('Cline Hub adapter is stopped', 'crash', false);
-            }
-            return runtime;
-        }
-        catch (error) {
-            if (signal.aborted && this.runtimePromise === pending && this.runtimeWaiters === 1) {
-                this.runtimePromise = null;
-                void pending
-                    .then((runtime) => this.disposeRuntimeOnce(runtime, 'mama_request_deadline'))
-                    .catch(() => undefined);
-            }
-            throw error;
-        }
-        finally {
-            this.runtimeWaiters -= 1;
-        }
-    }
-    async abortRoute(routeId, reason) {
-        const pendingRuntime = this.runtimePromise;
-        const session = this.sessions.get(routeId);
-        if (!pendingRuntime || !session) {
-            return;
-        }
-        const runtime = await pendingRuntime.catch(() => null);
-        await runtime?.client.abort(session.hubSessionId, reason).catch(() => undefined);
-    }
-    async quarantineRoute(routeId) {
-        const session = this.sessions.get(routeId);
-        if (!session) {
-            return;
-        }
-        if (this.sessions.get(routeId) === session) {
-            this.sessions.delete(routeId);
-            this.removeStableRoute(routeId);
-            this.markRouteForRebuild(routeId);
-        }
-        const pendingRuntime = this.runtimePromise;
-        if (pendingRuntime) {
-            void pendingRuntime
-                .then((runtime) => runtime.client.stop(session.hubSessionId))
-                .catch(() => undefined);
-        }
-    }
-    async disposeRuntimeOnce(runtime, reason) {
-        if (this.disposedRuntimes.has(runtime)) {
-            return;
-        }
-        this.disposedRuntimes.add(runtime);
-        await runtime.client.dispose(reason);
-    }
-    async runHubPrompt(routeId, stableRouteId, content, callbacks, promptOptions, deadlineSignal, timeoutMs) {
-        const runtime = await this.getRuntime(deadlineSignal);
-        const model = promptOptions?.model ?? this.options.model;
-        if (!model) {
-            throw new model_runner_js_1.ModelRunnerError('Cline model is required', 'auth_failure', false);
-        }
-        if (!runtime.apiKey && (this.options.provider ?? 'cline') === 'cline') {
-            const unauthenticatedRuntime = this.runtimePromise;
-            this.runtimePromise = null;
-            if (unauthenticatedRuntime) {
-                void this.disposeRuntimeOnce(runtime, 'mama_auth_reload').catch(() => undefined);
-            }
-            throw new model_runner_js_1.ModelRunnerError('Cline credentials are unavailable. Run: cline auth cline', 'auth_failure', false);
-        }
-        const previousRouteId = this.stableRoutes.get(stableRouteId);
-        if (previousRouteId && previousRouteId !== routeId) {
-            const previousSession = this.sessions.get(previousRouteId);
-            if (previousSession) {
-                await raceWithAbort(runtime.client.stop(previousSession.hubSessionId).catch(() => undefined), deadlineSignal);
-                this.sessions.delete(previousRouteId);
-            }
-        }
-        const requestedPolicy = promptOptions?.sessionPolicyFingerprint;
-        const allowedTools = promptOptions?.allowedTools ?? this.options.allowedTools ?? [];
-        const disallowedTools = promptOptions?.disallowedTools ?? this.options.disallowedTools ?? [];
-        const allowSpawnAgent = promptOptions?.allowSpawnAgent ?? this.options.allowSpawnAgent ?? false;
-        const allowAgentTeams = promptOptions?.allowAgentTeams ?? this.options.allowAgentTeams ?? false;
-        const requestedToolFingerprint = toolFingerprint(promptOptions?.hostToolBridge, allowedTools, disallowedTools, allowSpawnAgent, allowAgentTeams);
-        let session = this.sessions.get(routeId);
-        const mappedSessionWasMissing = session !== undefined &&
-            !(await raceWithAbort(runtime.client.get(session.hubSessionId), deadlineSignal));
-        if (mappedSessionWasMissing) {
-            this.sessions.delete(routeId);
-            this.removeStableRoute(routeId);
-            session = undefined;
-        }
-        const incompatibleSession = session &&
-            (promptOptions?.resumeSession === false ||
-                session.model !== model ||
-                session.policyFingerprint !== requestedPolicy ||
-                session.toolFingerprint !== requestedToolFingerprint)
-            ? session
-            : undefined;
-        let systemPrompt = promptOptions?.systemPrompt ?? this.systemPrompt;
-        if (mappedSessionWasMissing && promptOptions?.resumeInstructions) {
-            systemPrompt = await raceWithAbort(promptOptions.resumeInstructions(), deadlineSignal);
-        }
-        if (incompatibleSession) {
-            await raceWithAbort(runtime.client.stop(incompatibleSession.hubSessionId).catch(() => undefined), deadlineSignal);
-            this.sessions.delete(routeId);
-            this.removeStableRoute(routeId);
-            session = undefined;
-            if (promptOptions?.resumeInstructions) {
-                systemPrompt = await raceWithAbort(promptOptions.resumeInstructions(), deadlineSignal);
-            }
-        }
-        if (!session &&
-            promptOptions?.resumeSession !== false &&
-            this.routesRequiringRebuild.has(routeId) &&
-            promptOptions?.resumeInstructions) {
-            systemPrompt = await raceWithAbort(promptOptions.resumeInstructions(), deadlineSignal);
-        }
-        if (!session) {
-            session = await this.withSessionLifecycleLock(deadlineSignal, async () => {
-                const existingSession = this.sessions.get(routeId);
-                if (existingSession) {
-                    return existingSession;
-                }
-                await this.retireStaleSessions(runtime, routeId, deadlineSignal);
-                if (this.sessions.size >= this.maxSessions) {
-                    throw new model_runner_js_1.ModelRunnerError('Cline Hub session capacity is fully active; retry after an active request completes', 'crash', true);
-                }
-                const createdSession = await this.startHubSession(runtime, routeId, model, systemPrompt, requestedPolicy, promptOptions?.hostToolBridge, requestedToolFingerprint, promptOptions?.requestTimeout, allowedTools, disallowedTools, allowSpawnAgent, allowAgentTeams, deadlineSignal);
-                this.sessions.set(routeId, createdSession);
-                return createdSession;
-            });
-        }
-        this.stableRoutes.set(stableRouteId, routeId);
-        this.routesRequiringRebuild.delete(routeId);
-        session.lastActiveAt = Date.now();
-        const attemptController = new AbortController();
-        const ownerSignal = promptOptions?.toolExecutionContext?.signal;
-        const pendingTools = new Map();
-        const attempt = {
-            bridge: promptOptions?.hostToolBridge,
-            controller: attemptController,
-            signal: combineSignals(ownerSignal, attemptController.signal, deadlineSignal),
-            completed: new Map(),
-            pendingTools,
-            claimedToolCallIds: new Set(),
-            executedToolCallIds: new Set(),
-            inFlightTools: new Set(),
-        };
-        session.activeAttempt = attempt;
-        const unsubscribe = runtime.client.subscribe((event) => this.processHubEvent(event, session, attempt, pendingTools, callbacks), { sessionId: session.hubSessionId });
-        const abortOwner = () => {
-            const error = new model_runner_js_1.ModelRunnerError('Cline Hub request was aborted by its owner', 'unknown');
-            attemptController.abort(error);
-            void runtime.client.abort(session.hubSessionId, error).catch(() => undefined);
-        };
-        ownerSignal?.addEventListener('abort', abortOwner, { once: true });
-        try {
-            if (ownerSignal?.aborted) {
-                abortOwner();
-                throw new model_runner_js_1.ModelRunnerError('Cline Hub request was aborted by its owner', 'unknown');
-            }
-            const rawResult = await raceWithAbort(runtime.client.send({ sessionId: session.hubSessionId, prompt: content, timeoutMs }), deadlineSignal);
-            const result = parseAgentResult(rawResult);
-            const completedToolExchanges = [...attempt.completed.values()];
-            const completedTerminal = attempt.terminalResult?.terminalCode && attempt.terminalResult.abort
-                ? {
-                    code: attempt.terminalResult.terminalCode,
-                    message: attempt.terminalResult.content,
-                }
-                : (0, completed_terminal_result_js_1.completedCodeActTerminalError)(completedToolExchanges);
-            if (!completedTerminal && (attempt.terminalResult?.abort || attempt.terminalResult?.stop)) {
-                throw new model_runner_js_1.HostToolAbortError('MAMA host tool aborted the active Cline run', completedToolExchanges);
-            }
-            if (result.finishReason !== 'completed') {
-                const failure = safeProviderFailure(result.text.trim(), result.finishReason);
-                throw new model_runner_js_1.ModelRunnerError(failure.message, failure.code, failure.code !== 'auth_failure');
-            }
-            const unresolvedCodeActIds = [...pendingTools.values()]
-                .filter((toolUse) => toolUse.name === CLINE_CODE_ACT_TOOL_NAME)
-                .map((toolUse) => toolUse.id);
-            if (unresolvedCodeActIds.length > 0) {
-                throw new types_js_1.McpResultMissingError(unresolvedCodeActIds);
-            }
-            const promptResult = {
-                response: result.text,
-                session_id: session.hubSessionId,
-                cost_usd: result.usage?.totalCost,
-                duration_ms: result.durationMs,
-                usage: {
-                    input_tokens: result.usage?.inputTokens ?? 0,
-                    output_tokens: result.usage?.outputTokens ?? 0,
-                    cache_creation_input_tokens: result.usage?.cacheWriteTokens,
-                    cache_read_input_tokens: result.usage?.cacheReadTokens,
-                },
-                hasToolUse: false,
-                completedToolExchanges,
-                ...(completedTerminal ? { terminalError: completedTerminal } : {}),
-            };
-            if (completedTerminal) {
-                callbacks?.onError?.(new model_runner_js_1.HostToolTerminalError(completedTerminal.code, completedTerminal.message, completedToolExchanges));
-            }
-            else {
-                callbacks?.onFinal?.({ content: result.text, toolUseBlocks: [] });
-            }
-            return promptResult;
-        }
-        catch (error) {
-            const inFlightAtInterruption = [...attempt.inFlightTools];
-            if (inFlightAtInterruption.length > 0) {
-                if (!attempt.signal.aborted) {
-                    attemptController.abort(error instanceof Error
-                        ? error
-                        : new model_runner_js_1.ModelRunnerError('Cline Hub tool transport was interrupted', 'crash', false));
-                }
-                await this.waitForToolSettlement(inFlightAtInterruption);
-            }
-            const completedToolExchanges = [...attempt.completed.values()];
-            const completedTerminal = attempt.terminalResult?.terminalCode && attempt.terminalResult.abort
-                ? {
-                    code: attempt.terminalResult.terminalCode,
-                    message: attempt.terminalResult.content,
-                }
-                : (0, completed_terminal_result_js_1.completedCodeActTerminalError)(completedToolExchanges);
-            if (completedTerminal) {
-                throw new model_runner_js_1.HostToolTerminalError(completedTerminal.code, completedTerminal.message, completedToolExchanges);
-            }
-            if (attempt.terminalResult?.abort || attempt.terminalResult?.stop) {
-                throw new model_runner_js_1.HostToolAbortError('MAMA host tool aborted the active Cline run', completedToolExchanges);
-            }
-            if ((0, completed_terminal_result_js_1.completedCodeActMutationWasObserved)(completedToolExchanges)) {
-                throw new types_js_1.McpCompletedMutationInterruptedError(completedToolExchanges);
-            }
-            if (inFlightAtInterruption.length > 0) {
-                const unresolvedIds = [...attempt.pendingTools.values()]
-                    .filter((toolUse) => toolUse.name === CLINE_CODE_ACT_TOOL_NAME)
-                    .map((toolUse) => toolUse.id);
-                throw new types_js_1.McpResultMissingError(unresolvedIds.length > 0 ? unresolvedIds : [...attempt.claimedToolCallIds]);
-            }
-            throw error;
-        }
-        finally {
-            ownerSignal?.removeEventListener('abort', abortOwner);
-            unsubscribe();
-            if (session.activeAttempt === attempt) {
-                session.activeAttempt = undefined;
-            }
-            if (attempt.signal.aborted) {
-                if (this.sessions.get(routeId) === session) {
-                    this.sessions.delete(routeId);
-                    this.removeStableRoute(routeId);
-                    this.markRouteForRebuild(routeId);
-                }
-                void runtime.client.stop(session.hubSessionId).catch(() => undefined);
-            }
-        }
-    }
-    async waitForToolSettlement(inFlight) {
-        let timeoutHandle;
-        const timeout = new Promise((resolvePromise) => {
-            timeoutHandle = setTimeout(resolvePromise, CLINE_MUTATION_SETTLEMENT_GRACE_MS);
-            timeoutHandle.unref();
-        });
-        await Promise.race([Promise.all(inFlight).then(() => undefined), timeout]);
-        if (timeoutHandle) {
-            clearTimeout(timeoutHandle);
-        }
-    }
-    async startHubSession(runtime, routeId, model, systemPrompt, policyFingerprint, bridge, projectedToolFingerprint, requestTimeout, allowedTools, disallowedTools, allowSpawnAgent, allowAgentTeams, deadlineSignal) {
-        const session = {
-            routeId,
-            hubSessionId: '',
-            model,
-            policyFingerprint,
-            toolFingerprint: projectedToolFingerprint,
-            lastActiveAt: Date.now(),
-        };
-        const tools = (bridge?.tools ?? []).map((definition) => this.createProjectedTool(runtime, session, definition, requestTimeout));
-        const provider = this.options.provider ?? 'cline';
-        const cwd = this.options.cwd ?? process.cwd();
-        const toolPolicies = buildToolPolicies(bridge, allowedTools, disallowedTools);
-        const hasProjectedTools = (bridge?.tools.length ?? 0) > 0;
-        const hasNativeTools = allowedTools.includes('*') || allowedTools.length > 0;
-        const startPromise = runtime.client.start({
-            source: runtime.source,
-            interactive: true,
-            config: {
-                providerId: provider,
-                modelId: model,
-                apiKey: runtime.apiKey,
-                cwd,
-                workspaceRoot: cwd,
-                systemPrompt,
-                enableTools: hasNativeTools || hasProjectedTools,
-                enableSpawnAgent: allowSpawnAgent,
-                enableAgentTeams: allowAgentTeams,
-                disableMcpSettingsTools: !allowedTools.includes('*') && !allowedTools.some(cline_native_tool_policy_js_1.isClineMcpToolGrant),
-                toolPolicies,
-            },
-            localRuntime: { extraTools: tools },
-            sessionMetadata: {
-                source: 'mama-os',
-                routeId,
-                policyFingerprint,
-            },
-        });
-        let started;
-        try {
-            started = await raceWithAbort(startPromise, deadlineSignal);
-        }
-        catch (error) {
-            if (deadlineSignal.aborted) {
-                void startPromise
-                    .then((lateSession) => runtime.client.stop(lateSession.sessionId))
-                    .catch(() => undefined);
-            }
-            throw error;
-        }
-        if (!started.sessionId?.trim()) {
-            throw new Error('Cline Hub returned an empty session id');
-        }
-        session.hubSessionId = started.sessionId.trim();
-        return session;
-    }
-    createProjectedTool(runtime, session, definition, requestTimeout) {
-        const exposedName = definition.name === MAMA_CODE_ACT_TOOL_NAME ? CLINE_CODE_ACT_TOOL_NAME : definition.name;
-        return runtime.createTool({
-            name: exposedName,
-            description: definition.description,
-            inputSchema: { ...definition.inputSchema },
-            timeoutMs: Math.max(requestTimeout ?? this.options.requestTimeout ?? 600_000, 310_000),
-            retryable: false,
-            maxRetries: 0,
-            execute: async (input, context) => {
-                const attempt = session.activeAttempt;
-                const bridge = attempt?.bridge;
-                if (!attempt || !bridge) {
-                    throw new Error(`MAMA bridge is not active for Cline session ${session.hubSessionId}`);
-                }
-                if (attempt.terminalResult?.abort ||
-                    attempt.terminalResult?.stop ||
-                    attempt.terminalResult?.terminalCode) {
-                    throw new Error('MAMA host-tool attempt is already sealed');
-                }
-                const streamedToolUse = [...attempt.pendingTools.values()].find((toolUse) => toolUse.name === exposedName && !attempt.claimedToolCallIds.has(toolUse.id));
-                const callId = context.toolCallId?.trim() || streamedToolUse?.id || (0, node_crypto_1.randomUUID)();
-                attempt.claimedToolCallIds.add(callId);
-                const signal = combineSignals(context.signal, attempt.signal);
-                let settleTool = () => undefined;
-                const settlement = new Promise((resolvePromise) => {
-                    settleTool = resolvePromise;
-                });
-                attempt.inFlightTools.add(settlement);
-                try {
-                    const result = await bridge.execute({
-                        callId,
-                        name: definition.name,
-                        input,
-                        signal,
-                    });
-                    attempt.executedToolCallIds.add(callId);
-                    const exchange = {
-                        toolUse: {
-                            type: 'tool_use',
-                            id: callId,
-                            name: exposedName,
-                            input,
-                        },
-                        toolResult: {
-                            type: 'tool_result',
-                            tool_use_id: callId,
-                            content: result.content,
-                            is_error: result.isError,
-                        },
-                    };
-                    attempt.completed.set(callId, exchange);
-                    if (result.terminalCode || result.abort || result.stop) {
-                        attempt.terminalResult = result;
-                        void runtime.client
-                            .abort(session.hubSessionId, new Error('MAMA host tool sealed run'))
-                            .catch(() => undefined);
-                    }
-                    if (result.isError) {
-                        throw new Error('MAMA projected tool returned an error');
-                    }
-                    return result.content;
-                }
-                finally {
-                    settleTool();
-                    attempt.inFlightTools.delete(settlement);
-                }
-            },
-        });
-    }
-    processHubEvent(raw, session, attempt, pendingTools, callbacks) {
-        if (!isRecord(raw) || raw.type !== 'agent_event' || !isRecord(raw.payload)) {
-            return;
-        }
-        if (stringValue(raw.payload, 'sessionId') !== session.hubSessionId ||
-            !isRecord(raw.payload.event)) {
-            return;
-        }
-        const event = raw.payload.event;
-        const eventType = stringValue(event, 'type');
-        const contentType = stringValue(event, 'contentType');
-        if (eventType === 'content_start' && contentType === 'text') {
-            const text = stringValue(event, 'text');
-            if (text) {
-                callbacks?.onDelta?.(text);
-            }
-            return;
-        }
-        if (contentType !== 'tool') {
-            return;
-        }
-        const toolCallId = stringValue(event, 'toolCallId');
-        if (!toolCallId) {
-            return;
-        }
-        if (eventType === 'content_start') {
-            const toolName = stringValue(event, 'toolName');
-            if (!toolName) {
-                return;
-            }
-            const input = isRecord(event.input) ? event.input : {};
-            pendingTools.set(toolCallId, {
-                type: 'tool_use',
-                id: toolCallId,
-                name: toolName,
-                input,
-            });
-            callbacks?.onToolUse?.(toolName, input);
-            return;
-        }
-        if (eventType !== 'content_end') {
-            return;
-        }
-        const toolUse = pendingTools.get(toolCallId);
-        if (!toolUse) {
-            return;
-        }
-        const isError = typeof event.error === 'string' && event.error.length > 0;
-        if (attempt.executedToolCallIds.has(toolCallId) && !attempt.completed.has(toolCallId)) {
-            attempt.completed.set(toolCallId, {
-                toolUse,
-                toolResult: {
-                    type: 'tool_result',
-                    tool_use_id: toolCallId,
-                    content: normalizeToolOutput(isError ? event.error : event.output),
-                    is_error: isError,
-                },
-            });
-        }
-        pendingTools.delete(toolCallId);
-        attempt.claimedToolCallIds.delete(toolCallId);
-        callbacks?.onToolComplete?.(toolUse.name, toolCallId, isError);
-    }
-    removeStableRoute(routeId) {
-        for (const [stableRouteId, mappedRouteId] of this.stableRoutes) {
-            if (mappedRouteId === routeId) {
-                this.stableRoutes.delete(stableRouteId);
-            }
-        }
-    }
-    markRouteForRebuild(routeId) {
-        this.routesRequiringRebuild.delete(routeId);
-        this.routesRequiringRebuild.add(routeId);
-        while (this.routesRequiringRebuild.size > this.maxSessions) {
-            const oldest = this.routesRequiringRebuild.values().next().value;
-            if (!oldest) {
-                break;
-            }
-            this.routesRequiringRebuild.delete(oldest);
-        }
-    }
-    async retireRoute(runtime, routeId, signal) {
-        const session = this.sessions.get(routeId);
-        if (!session) {
-            return;
-        }
-        await raceWithAbort(runtime.client.stop(session.hubSessionId).catch(() => undefined), signal);
-        this.sessions.delete(routeId);
-        this.removeStableRoute(routeId);
-    }
-    async retireStaleSessions(runtime, protectedRouteId, signal) {
-        const expiry = Date.now() - this.sessionTtlMs;
-        const expired = [...this.sessions.entries()]
-            .filter(([routeId, session]) => routeId !== protectedRouteId &&
-            !this.activeRoutes.has(routeId) &&
-            !session.activeAttempt &&
-            session.lastActiveAt < expiry)
-            .map(([routeId]) => routeId);
-        for (const routeId of expired) {
-            await this.retireRoute(runtime, routeId, signal);
-        }
-        if (this.sessions.has(protectedRouteId)) {
-            return;
-        }
-        while (this.sessions.size >= this.maxSessions) {
-            const oldest = [...this.sessions.entries()]
-                .filter(([routeId, session]) => !this.activeRoutes.has(routeId) && !session.activeAttempt)
-                .sort((left, right) => left[1].lastActiveAt - right[1].lastActiveAt)[0]?.[0];
-            if (!oldest) {
-                return;
-            }
-            await this.retireRoute(runtime, oldest, signal);
-        }
-    }
-    normalizeError(error) {
-        if (error instanceof model_runner_js_1.ModelRunnerError ||
-            error instanceof model_runner_js_1.HostToolAbortError ||
-            error instanceof model_runner_js_1.HostToolTerminalError ||
-            error instanceof types_js_1.McpCompletedMutationInterruptedError ||
-            error instanceof types_js_1.McpResultMissingError) {
-            return error;
-        }
-        const rawMessage = error instanceof Error ? error.message : String(error);
-        const failure = safeProviderFailure(rawMessage, 'exception');
-        return new model_runner_js_1.ModelRunnerError(failure.message, failure.code, failure.code !== 'auth_failure');
-    }
-    getSessionPolicyStatus(options) {
-        const routeId = options.sessionId ?? options.sessionKey ?? this.sessionId;
-        const session = this.sessions.get(routeId);
-        if (!session) {
-            return 'missing';
-        }
-        const allowedTools = options.allowedTools ?? this.options.allowedTools ?? [];
-        const disallowedTools = options.disallowedTools ?? this.options.disallowedTools ?? [];
-        return session.policyFingerprint === options.sessionPolicyFingerprint &&
-            session.toolFingerprint ===
-                toolFingerprint(options.hostToolBridge, allowedTools, disallowedTools, options.allowSpawnAgent ?? this.options.allowSpawnAgent ?? false, options.allowAgentTeams ?? this.options.allowAgentTeams ?? false)
-            ? 'compatible'
-            : 'mismatch';
-    }
-    setSessionId(id) {
-        this.sessionId = id;
-    }
-    setSystemPrompt(prompt) {
-        this.systemPrompt = prompt;
-    }
-    async sendMessage(content, callbacks) {
-        return this.prompt(content, callbacks, { resumeSession: true });
-    }
-    getSessionId() {
-        return this.sessionId;
-    }
-    isHealthy() {
-        return !this.stopped;
-    }
-    isReady() {
-        return !this.stopped;
-    }
-    getMetrics() {
-        return {
-            requestCount: this.requestCount,
-            failureCount: this.failureCount,
-            avgLatencyMs: this.requestCount > 0 ? Math.round(this.totalLatencyMs / this.requestCount) : 0,
-            lastRequestAt: this.lastRequestAt,
-        };
-    }
-    async stop() {
-        if (this.stopped) {
-            return;
-        }
-        this.stopped = true;
-        const pendingRuntime = this.runtimePromise;
-        const runtime = pendingRuntime ? await this.waitForCleanup(pendingRuntime, 1_000, null) : null;
-        if (!runtime) {
-            this.sessions.clear();
-            this.stableRoutes.clear();
-            this.routesRequiringRebuild.clear();
-            if (pendingRuntime) {
-                void pendingRuntime
-                    .then((lateRuntime) => this.disposeRuntimeOnce(lateRuntime, 'mama_shutdown'))
-                    .catch(() => undefined);
-            }
-            return;
-        }
-        const sessions = [...this.sessions.values()];
-        const shutdownError = new model_runner_js_1.ModelRunnerError('Cline Hub adapter is shutting down', 'crash', false);
-        for (const session of sessions) {
-            session.activeAttempt?.controller.abort(shutdownError);
-            if (session.activeAttempt) {
-                void runtime.client.abort(session.hubSessionId, shutdownError).catch(() => undefined);
-            }
-        }
-        const inFlight = sessions.flatMap((session) => [
-            ...(session.activeAttempt?.inFlightTools ?? []),
-        ]);
-        if (inFlight.length > 0) {
-            await this.waitForToolSettlement(inFlight);
-        }
-        this.sessions.clear();
-        this.stableRoutes.clear();
-        this.routesRequiringRebuild.clear();
-        this.activeRoutes.clear();
-        void Promise.allSettled(sessions.map((session) => runtime.client.stop(session.hubSessionId)));
-        await this.waitForCleanup(this.disposeRuntimeOnce(runtime, 'mama_shutdown'), 1_000, undefined);
-    }
-    async waitForCleanup(operation, timeoutMs, fallback) {
-        let timeoutHandle;
-        const timeout = new Promise((resolvePromise) => {
-            timeoutHandle = setTimeout(() => resolvePromise(fallback), timeoutMs);
-            timeoutHandle.unref();
-        });
-        const result = await Promise.race([operation, timeout]);
-        if (timeoutHandle) {
-            clearTimeout(timeoutHandle);
-        }
-        return result;
-    }
-}
-exports.ClineCLIAdapter = ClineCLIAdapter;
-//# sourceMappingURL=cline-cli-adapter.js.map