@geminilight/mindos 1.1.26 → 1.1.28

package/dist/session/index.js

@@ -1,1456 +1,2 @@
-import { redactSensitiveObject, redactSensitiveText } from './redaction.js';
-export { redactSensitiveObject, redactSensitiveText } from './redaction.js';
-export const MINDOS_SESSION_STREAM_SCHEMA = {
-    protocol: 'mindos.session.events',
-    version: 1,
-    events: [
-        'session.started',
-        'message.delta',
-        'tool.started',
-        'tool.completed',
-        'session.completed',
-        'session.failed',
-    ],
-};
-export function createMindosSessionEvent(input) {
-    return {
-        ...input,
-        timestamp: input.timestamp ?? new Date().toISOString(),
-    };
-}
-export const MINDOS_ASK_STREAM_EVENT_TYPES = [
-    'text_delta',
-    'thinking_delta',
-    'agent_run_context',
-    'tool_start',
-    'tool_delta',
-    'tool_end',
-    'runtime_permission_request',
-    'runtime_permission_resolved',
-    'user_question_start',
-    'user_question_answered',
-    'user_question_cancelled',
-    'runtime_binding',
-    'done',
-    'error',
-    'status',
-];
-export const MINDOS_SSE_HEADERS = {
-    'Content-Type': 'text/event-stream',
-    'Cache-Control': 'no-cache, no-transform',
-    Connection: 'keep-alive',
-    'X-Accel-Buffering': 'no',
-};
-function isRecord(value) {
-    return !!value && typeof value === 'object';
-}
-function nestedRecord(value, key) {
-    const child = value[key];
-    return isRecord(child) ? child : undefined;
-}
-export function isTextDeltaEvent(event) {
-    if (!isRecord(event) || event.type !== 'message_update')
-        return false;
-    return nestedRecord(event, 'assistantMessageEvent')?.type === 'text_delta';
-}
-export function getTextDelta(event) {
-    if (!isRecord(event))
-        return '';
-    const assistantEvent = nestedRecord(event, 'assistantMessageEvent');
-    return typeof assistantEvent?.delta === 'string' ? assistantEvent.delta : '';
-}
-export function isThinkingDeltaEvent(event) {
-    if (!isRecord(event) || event.type !== 'message_update')
-        return false;
-    return nestedRecord(event, 'assistantMessageEvent')?.type === 'thinking_delta';
-}
-export function getThinkingDelta(event) {
-    return getTextDelta(event);
-}
-export function isToolExecutionStartEvent(event) {
-    return isRecord(event) && event.type === 'tool_execution_start';
-}
-export function getToolExecutionStart(event) {
-    if (!isRecord(event))
-        return { toolCallId: '', toolName: 'unknown', args: {} };
-    return {
-        toolCallId: typeof event.toolCallId === 'string' ? event.toolCallId : '',
-        toolName: typeof event.toolName === 'string' ? event.toolName : 'unknown',
-        args: event.args ?? {},
-    };
-}
-export function isToolExecutionEndEvent(event) {
-    return isRecord(event) && event.type === 'tool_execution_end';
-}
-export function getToolExecutionEnd(event) {
-    if (!isRecord(event))
-        return { toolCallId: '', output: '', isError: false };
-    const result = nestedRecord(event, 'result');
-    const content = Array.isArray(result?.content) ? result.content : [];
-    const output = content
-        .filter((part) => isRecord(part) && part.type === 'text')
-        .map((part) => part.text ?? '')
-        .join('');
-    return {
-        toolCallId: typeof event.toolCallId === 'string' ? event.toolCallId : '',
-        output,
-        isError: event.isError === true,
-    };
-}
-export function isTurnEndEvent(event) {
-    return isRecord(event) && event.type === 'turn_end';
-}
-export function getTurnEndData(event) {
-    if (!isRecord(event))
-        return { toolResults: [] };
-    return {
-        toolResults: Array.isArray(event.toolResults)
-            ? event.toolResults.filter((item) => isRecord(item) && typeof item.toolName === 'string')
-            : [],
-    };
-}
-export function createMindosAgentEventReducer(options) {
-    const stepHistory = [];
-    let stepCount = 0;
-    let loopCooldown = 0;
-    let lastModelError = '';
-    const loopWarningMessage = options.loopWarningMessage
-        ?? '[SYSTEM WARNING] You appear to be in a loop — repeating the same tool calls in a cycle. Try a completely different approach or ask the user for clarification.';
-    return {
-        get lastModelError() {
-            return lastModelError;
-        },
-        get stepCount() {
-            return stepCount;
-        },
-        handle(event) {
-            if (isTextDeltaEvent(event)) {
-                return { events: [{ type: 'text_delta', delta: getTextDelta(event) }], hasVisibleContent: true };
-            }
-            if (isThinkingDeltaEvent(event)) {
-                return { events: [{ type: 'thinking_delta', delta: getThinkingDelta(event) }], hasVisibleContent: true };
-            }
-            if (isToolExecutionStartEvent(event)) {
-                const { toolCallId, toolName, args } = getToolExecutionStart(event);
-                return {
-                    events: [{ type: 'tool_start', toolCallId, toolName, args: sanitizeToolArgs(toolName, args) }],
-                    hasVisibleContent: true,
-                };
-            }
-            if (isToolExecutionEndEvent(event)) {
-                const { toolCallId, output, isError } = getToolExecutionEnd(event);
-                return {
-                    events: [{ type: 'tool_end', toolCallId, output: sanitizeToolOutput(output), isError }],
-                    hasVisibleContent: false,
-                    toolExecutions: 1,
-                };
-            }
-            if (isTurnEndEvent(event)) {
-                stepCount += 1;
-                const effect = {
-                    events: [],
-                    hasVisibleContent: false,
-                    stepCount,
-                };
-                const turnUsage = event.usage;
-                if (turnUsage && typeof turnUsage.inputTokens === 'number') {
-                    effect.tokenUsage = { input: turnUsage.inputTokens, output: turnUsage.outputTokens ?? 0 };
-                }
-                const { toolResults } = getTurnEndData(event);
-                if (toolResults.length > 0) {
-                    const newEntries = toolResults.map((toolResult) => ({
-                        tool: toolResult.toolName ?? 'unknown',
-                        input: JSON.stringify(toolResult.content, null, 0),
-                    }));
-                    stepHistory.push(...newEntries);
-                    if (stepHistory.length > 20)
-                        stepHistory.splice(0, stepHistory.length - 20);
-                }
-                if (loopCooldown > 0) {
-                    loopCooldown -= 1;
-                }
-                else if (detectMindosAgentLoop(stepHistory)) {
-                    loopCooldown = 3;
-                    effect.steerMessage = loopWarningMessage;
-                }
-                if (stepCount >= options.stepLimit) {
-                    effect.shouldAbort = true;
-                }
-                return effect;
-            }
-            if (isRecord(event) && event.type === 'agent_end') {
-                const msgs = Array.isArray(event.messages) ? event.messages : [];
-                for (let i = msgs.length - 1; i >= 0; i -= 1) {
-                    const message = msgs[i];
-                    if (isRecord(message)
-                        && message.role === 'assistant'
-                        && message.stopReason === 'error'
-                        && typeof message.errorMessage === 'string') {
-                        lastModelError = message.errorMessage;
-                        return { events: [], hasVisibleContent: false, lastModelError };
-                    }
-                }
-            }
-            return { events: [], hasVisibleContent: false };
-        },
-    };
-}
-export function sanitizeToolArgs(toolName, args) {
-    if (!isRecord(args))
-        return typeof args === 'string' ? redactSensitiveText(args) : redactSensitiveObject(args);
-    if (toolName === 'batch_create_files' && Array.isArray(args.files)) {
-        return redactSensitiveObject({
-            ...args,
-            files: args.files
-                .filter(isRecord)
-                .map((file) => ({
-                path: file.path,
-                ...(file.description ? { description: file.description } : {}),
-            })),
-        });
-    }
-    if (typeof args.content === 'string' && args.content.length > 200) {
-        return redactSensitiveObject({ ...args, content: `[${args.content.length} chars]` });
-    }
-    if (typeof args.text === 'string' && args.text.length > 200) {
-        return redactSensitiveObject({ ...args, text: `[${args.text.length} chars]` });
-    }
-    return redactSensitiveObject(args);
-}
-export function sanitizeToolOutput(output) {
-    return redactSensitiveText(output);
-}
-export function encodeMindosSseEvent(event) {
-    return `data:${JSON.stringify(event)}\n\n`;
-}
-export function parseMindosSseLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith('data:'))
-        return null;
-    const json = trimmed.slice(5).trim();
-    if (!json || json === '[DONE]')
-        return null;
-    try {
-        const parsed = JSON.parse(json);
-        if (!isRecord(parsed) || typeof parsed.type !== 'string')
-            return null;
-        if (!MINDOS_ASK_STREAM_EVENT_TYPES.includes(parsed.type))
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-export function normalizeMindosAskMode(mode) {
-    if (mode === 'organize')
-        return 'organize';
-    return 'agent';
-}
-export function normalizeMindosAskStepLimit(options) {
-    const defaultMaxSteps = options.agentMaxSteps ?? 20;
-    const raw = typeof options.requestedMaxSteps === 'number' && Number.isFinite(options.requestedMaxSteps)
-        ? options.requestedMaxSteps
-        : defaultMaxSteps;
-    return Math.min(999, Math.max(1, Number(raw)));
-}
-export function resolveMindosAgentTimeoutMs(raw = undefined, defaultMs = 600_000) {
-    if (!raw)
-        return defaultMs;
-    const parsed = Number.parseInt(raw, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultMs;
-}
-export function expandMindosAskAttachedFiles(raw, collectAllFiles, maxDirFiles = 30) {
-    if (!Array.isArray(raw))
-        return raw;
-    const result = [];
-    let allFiles;
-    for (const entry of raw) {
-        if (entry.endsWith('/')) {
-            allFiles ??= collectAllFiles();
-            let count = 0;
-            for (const filePath of allFiles) {
-                if (filePath.startsWith(entry) && ++count <= maxDirFiles)
-                    result.push(filePath);
-            }
-        }
-        else {
-            result.push(entry);
-        }
-    }
-    return result;
-}
-export function loadMindosAskFileContext(attachedFiles, currentFile, mode, services) {
-    const contextParts = [];
-    const failedFiles = [];
-    const seen = new Set();
-    let cumulativeSize = 0;
-    function appendFile(filePath, label) {
-        if (seen.has(filePath))
-            return;
-        seen.add(filePath);
-        const validation = services.validateFileSize?.(filePath, cumulativeSize) ?? {
-            valid: true,
-            newCumulativeSize: cumulativeSize,
-        };
-        if (!validation.valid) {
-            services.warn?.(`[ask] ${mode}: file size validation failed for "${filePath}": ${validation.error ?? 'invalid'}`);
-            failedFiles.push(filePath);
-            return;
-        }
-        try {
-            const raw = services.readFile(filePath);
-            const content = services.truncate ? services.truncate(raw) : raw;
-            contextParts.push(`### ${label}: ${filePath}\n\n${content}`);
-            cumulativeSize = validation.newCumulativeSize;
-        }
-        catch (error) {
-            services.warn?.(`[ask] ${mode}: failed to read ${label.startsWith('Attached') ? 'attached file' : 'currentFile'} "${filePath}":`, error);
-            failedFiles.push(filePath);
-        }
-    }
-    for (const filePath of attachedFiles ?? [])
-        appendFile(filePath, 'Attached file from the MindOS knowledge base');
-    if (currentFile)
-        appendFile(currentFile, 'Current file from the MindOS knowledge base');
-    return { contextParts, failedFiles };
-}
-export function createMindosUploadedFileParts(uploadedFiles, options = {}) {
-    if (!Array.isArray(uploadedFiles))
-        return [];
-    const maxBytes = options.maxBytes ?? 100_000;
-    const limit = options.limit ?? 8;
-    const parts = [];
-    for (const file of uploadedFiles.slice(0, limit)) {
-        if (!file || typeof file !== 'object')
-            continue;
-        const record = file;
-        if (typeof record.name !== 'string' || typeof record.content !== 'string')
-            continue;
-        const content = record.content.length > maxBytes
-            ? `${record.content.slice(0, maxBytes)}\n\n[...truncated]`
-            : record.content;
-        parts.push(`### ${record.name}\n\n${content}`);
-    }
-    return parts;
-}
-export function buildMindosExternalRuntimePrompt(input) {
-    const prompt = input.prompt.trim();
-    const contextSections = [];
-    const modeGuidance = getExternalRuntimeModeGuidance(input.mode);
-    if (modeGuidance) {
-        contextSections.push([
-            '## MindOS Request Guidance',
-            modeGuidance,
-        ].join('\n'));
-    }
-    contextSections.push([
-        '## MindOS Chat Panel Bridge',
-        'If the available tools include `AskUserQuestion`, use it for user confirmations or structured choices that affect the next action. Keep questions concise and include concrete options.',
-    ].join('\n'));
-    if (input.fileContext?.contextParts.length) {
-        contextSections.push([
-            '## Attached files from the MindOS knowledge base',
-            'The following content already exists in MindOS and was explicitly attached for this turn. Cite stable paths when using it.',
-            '',
-            input.fileContext.contextParts.join('\n\n---\n\n'),
-        ].join('\n'));
-    }
-    if (input.uploadedParts?.length) {
-        contextSections.push([
-            '## Files uploaded by the user for this request',
-            'The user uploaded the following file content for this turn. It may not exist in the MindOS knowledge base yet; use it directly unless it is saved first.',
-            '',
-            input.uploadedParts.join('\n\n---\n\n'),
-        ].join('\n'));
-    }
-    if (input.recalledKnowledge?.length) {
-        const block = input.recalledKnowledge
-            .map((item) => `### ${item.path}\n\n${item.content}`)
-            .join('\n\n---\n\n');
-        contextSections.push([
-            '## Auto-Recalled MindOS Knowledge',
-            'MindOS found these related notes for the user request. Cite file paths when relying on them.',
-            '',
-            block,
-        ].join('\n'));
-    }
-    if (input.fileContext?.failedFiles.length) {
-        contextSections.push([
-            '## Unavailable MindOS Context',
-            `These attached files could not be loaded: ${input.fileContext.failedFiles.join(', ')}`,
-        ].join('\n'));
-    }
-    if (contextSections.length === 0)
-        return prompt;
-    return [
-        prompt,
-        '---',
-        '## MindOS Turn Context',
-        ...contextSections,
-    ].filter(Boolean).join('\n\n');
-}
-function getExternalRuntimeModeGuidance(mode) {
-    if (mode === 'organize') {
-        return 'Prioritize classification, cleanup, and knowledge organization. Use uploaded or selected materials as source material for well-structured MindOS notes when tools and permissions allow it.';
-    }
-    return null;
-}
-export function safeParseMindosJsonObject(raw) {
-    if (!raw)
-        return {};
-    try {
-        const parsed = JSON.parse(raw);
-        return isRecord(parsed) ? parsed : {};
-    }
-    catch {
-        return {};
-    }
-}
-export function dirnameOfMindosPath(filePath) {
-    if (!filePath)
-        return null;
-    const normalized = filePath.replace(/\\/g, '/');
-    const idx = normalized.lastIndexOf('/');
-    if (idx <= 0)
-        return null;
-    return normalized.slice(0, idx);
-}
-export function isMindosTransientError(err) {
-    const msg = err.message.toLowerCase();
-    if (msg.includes('timeout') || msg.includes('timed out') || msg.includes('etimedout'))
-        return true;
-    if (msg.includes('429') || msg.includes('rate limit') || msg.includes('too many requests'))
-        return true;
-    if (/\b5\d{2}\b/.test(msg) || msg.includes('internal server error') || msg.includes('service unavailable'))
-        return true;
-    if (msg.includes('econnreset') || msg.includes('econnrefused') || msg.includes('socket hang up'))
-        return true;
-    if (msg.includes('overloaded') || msg.includes('capacity'))
-        return true;
-    return false;
-}
-const MINDOS_NON_RETRYABLE_STATUS = new Set([401, 403, 429]);
-const MINDOS_NON_RETRYABLE_PATTERNS = [
-    /api.?key/i,
-    /model.*not.?found/i,
-    /authentication/i,
-    /unauthorized/i,
-    /forbidden/i,
-];
-export function isMindosRetryableError(err, httpStatus) {
-    if (err instanceof DOMException && err.name === 'AbortError')
-        return false;
-    if (httpStatus && MINDOS_NON_RETRYABLE_STATUS.has(httpStatus))
-        return false;
-    if (err instanceof Error) {
-        const msg = err.message;
-        if (MINDOS_NON_RETRYABLE_PATTERNS.some((pattern) => pattern.test(msg)))
-            return false;
-    }
-    return true;
-}
-export function mindosRetryDelay(attempt) {
-    return Math.min(1000 * 2 ** attempt, 10_000);
-}
-export function sleepMindos(ms, signal) {
-    return new Promise((resolveSleep, reject) => {
-        const abortReason = () => signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError');
-        if (signal?.aborted) {
-            reject(abortReason());
-            return;
-        }
-        const timer = setTimeout(resolveSleep, ms);
-        signal?.addEventListener('abort', () => {
-            clearTimeout(timer);
-            reject(abortReason());
-        }, { once: true });
-    });
-}
-export async function runMindosAskWithRetry(options) {
-    const maxRetries = options.maxRetries ?? 3;
-    const isTransient = options.isTransientError ?? isMindosTransientError;
-    const delayForAttempt = options.retryDelay ?? mindosRetryDelay;
-    const wait = options.sleep ?? sleepMindos;
-    const retryMessage = options.retryMessage ?? ((attempt, max) => `Request failed, retrying (${attempt}/${max})...`);
-    let lastError = null;
-    for (let attempt = 1; attempt <= maxRetries; attempt += 1) {
-        try {
-            await options.execute(attempt);
-            return null;
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            await options.onAttemptError?.(lastError, attempt);
-            const canRetry = !options.hasContent() && attempt < maxRetries && isTransient(lastError);
-            if (!canRetry)
-                break;
-            options.send({ type: 'status', message: retryMessage(attempt, maxRetries) });
-            await wait(delayForAttempt(attempt), options.signal);
-        }
-    }
-    return lastError;
-}
-export function mapMindosAcpUpdateToSseEvents(update, options = {}) {
-    switch (update.type) {
-        case 'agent_message_chunk':
-        case 'text':
-            if (!update.text)
-                return { events: [], hasVisibleContent: false };
-            return { events: [{ type: 'text_delta', delta: update.text }], hasVisibleContent: true };
-        case 'agent_thought_chunk':
-            if (!update.text)
-                return { events: [], hasVisibleContent: false };
-            return { events: [{ type: 'thinking_delta', delta: update.text }], hasVisibleContent: true };
-        case 'tool_call':
-            if (!update.toolCall)
-                return { events: [], hasVisibleContent: false };
-            return {
-                events: [{
-                        type: 'tool_start',
-                        toolCallId: update.toolCall.toolCallId,
-                        toolName: update.toolCall.title ?? update.toolCall.kind ?? 'tool',
-                        args: sanitizeToolArgs(update.toolCall.title ?? update.toolCall.kind ?? 'tool', safeParseMindosJsonObject(update.toolCall.rawInput)),
-                    }],
-                hasVisibleContent: true,
-            };
-        case 'tool_call_update':
-            if (!update.toolCall || (update.toolCall.status !== 'completed' && update.toolCall.status !== 'failed')) {
-                return { events: [], hasVisibleContent: false };
-            }
-            return {
-                events: [{
-                        type: 'tool_end',
-                        toolCallId: update.toolCall.toolCallId,
-                        output: sanitizeToolOutput(update.toolCall.rawOutput ?? ''),
-                        isError: update.toolCall.status === 'failed',
-                    }],
-                hasVisibleContent: false,
-            };
-        case 'plan':
-            if (!update.plan?.entries)
-                return { events: [], hasVisibleContent: false };
-            return {
-                events: [{
-                        type: 'text_delta',
-                        delta: `\n\n${update.plan.entries.map((entry) => `${planEntryIcon(entry.status)} ${entry.content ?? ''}`).join('\n')}\n\n`,
-                    }],
-                hasVisibleContent: true,
-            };
-        case 'error':
-            if (options.suppressErrors)
-                return { events: [], hasVisibleContent: false };
-            return { events: [{ type: 'error', message: update.error ?? 'ACP agent error' }], hasVisibleContent: false };
-        default:
-            return { events: [], hasVisibleContent: false };
-    }
-}
-function planEntryIcon(status) {
-    if (status === 'completed')
-        return '\u2705';
-    if (status === 'in_progress')
-        return '\u26a1';
-    return '\u23f3';
-}
-export async function runMindosAcpAskSession(options) {
-    let sessionId;
-    const closeCurrentSession = async () => {
-        if (!sessionId)
-            return;
-        const id = sessionId;
-        sessionId = undefined;
-        await options.closeSession(id).catch(() => { });
-    };
-    try {
-        const timeoutMs = options.timeoutMs ?? resolveMindosAgentTimeoutMs();
-        const lastError = await runMindosAskWithRetry({
-            maxRetries: options.maxRetries,
-            signal: options.signal,
-            hasContent: options.hasContent,
-            send: options.send,
-            sleep: options.sleep,
-            retryDelay: options.retryDelay,
-            onAttemptError: closeCurrentSession,
-            execute: async () => {
-                await closeCurrentSession();
-                const session = await options.createSession(options.agentId, { cwd: options.cwd });
-                sessionId = session.id;
-                let removeAbortListener;
-                const abortPrompt = new Promise((_resolve, reject) => {
-                    if (!options.signal)
-                        return;
-                    const abortReason = () => options.signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError');
-                    if (options.signal.aborted) {
-                        void options.cancelPrompt?.(session.id).catch(() => { });
-                        reject(abortReason());
-                        return;
-                    }
-                    const onAbort = () => {
-                        void options.cancelPrompt?.(session.id).catch(() => { });
-                        reject(abortReason());
-                    };
-                    options.signal.addEventListener('abort', onAbort, { once: true });
-                    removeAbortListener = () => options.signal?.removeEventListener('abort', onAbort);
-                });
-                await runMindosWithTimeout(Promise.race([
-                    options.promptStream(sessionId, options.prompt, (update) => {
-                        const mapped = mapMindosAcpUpdateToSseEvents(update, { suppressErrors: options.hasContent() });
-                        if (mapped.hasVisibleContent)
-                            options.onVisibleContent?.();
-                        for (const event of mapped.events)
-                            options.send(event);
-                    }, options.signal),
-                    abortPrompt,
-                ]).finally(() => removeAbortListener?.()), timeoutMs, options.timeoutMessage?.(timeoutMs) ?? `ACP agent execution timeout after ${timeoutMs / 1000} seconds`);
-            },
-        });
-        if (lastError) {
-            options.send({ type: 'error', message: options.errorMessage?.(lastError) ?? `ACP Agent Error: ${lastError.message}` });
-            return { error: lastError };
-        }
-        options.send({ type: 'done' });
-        return {};
-    }
-    finally {
-        await closeCurrentSession();
-    }
-}
-export async function runMindosWithTimeout(promise, timeoutMs, message) {
-    let timer;
-    const timeout = new Promise((_resolve, reject) => {
-        timer = setTimeout(() => {
-            const error = new Error(message);
-            error.code = 'TIMEOUT';
-            reject(error);
-        }, timeoutMs);
-    });
-    try {
-        return await Promise.race([promise, timeout]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-async function runMindosAbortable(promise, signal, onAbort, message) {
-    if (!signal)
-        return promise;
-    const abortReason = () => {
-        const reason = signal.reason;
-        if (reason instanceof Error)
-            return reason;
-        const error = new Error(typeof reason === 'string' && reason ? reason : message);
-        error.name = 'AbortError';
-        return error;
-    };
-    if (signal.aborted) {
-        await onAbort();
-        throw abortReason();
-    }
-    let removeAbortListener;
-    const abortPromise = new Promise((_resolve, reject) => {
-        const abort = () => {
-            void Promise.resolve(onAbort()).finally(() => reject(abortReason()));
-        };
-        signal.addEventListener('abort', abort, { once: true });
-        removeAbortListener = () => signal.removeEventListener('abort', abort);
-    });
-    try {
-        return await Promise.race([promise, abortPromise]);
-    }
-    finally {
-        removeAbortListener?.();
-    }
-}
-export async function runMindosPiAgentAskSession(options) {
-    let hasContent = false;
-    let lastModelError = '';
-    const effectiveBaseUrlKey = options.effectiveBaseUrlKey ?? options.baseUrl ?? 'default';
-    const reducer = createMindosAgentEventReducer({ stepLimit: options.stepLimit });
-    options.session.subscribe((event) => {
-        const effect = reducer.handle(event);
-        if (effect.hasVisibleContent)
-            hasContent = true;
-        for (const sseEvent of effect.events)
-            options.send(sseEvent);
-        if (effect.toolExecutions)
-            options.onToolExecution?.();
-        if (effect.tokenUsage)
-            options.onTokens?.(effect.tokenUsage.input, effect.tokenUsage.output);
-        if (effect.steerMessage)
-            void options.session.steer(effect.steerMessage);
-        if (effect.shouldAbort)
-            void options.session.abort();
-        if (effect.lastModelError)
-            lastModelError = effect.lastModelError;
-        if (effect.stepCount)
-            options.onStep?.(effect.stepCount, options.stepLimit);
-    });
-    const handledCachedProxyFallback = await runMindosAskProxyFallback({
-        phase: 'before-stream',
-        provider: options.provider,
-        baseUrl: options.baseUrl,
-        compatMode: options.compatMode,
-        send: options.send,
-        messages: options.proxyMessages,
-        runFallback: options.runFallback,
-    });
-    if (handledCachedProxyFallback)
-        return { hasContent, lastModelError };
-    const timeoutMs = options.timeoutMs ?? resolveMindosAgentTimeoutMs();
-    const lastPromptError = await runMindosAskWithRetry({
-        signal: options.signal,
-        hasContent: () => hasContent,
-        send: options.send,
-        sleep: options.sleep,
-        retryDelay: options.retryDelay,
-        execute: async () => {
-            await runMindosWithTimeout(runMindosAbortable(options.session.prompt(options.prompt, options.promptOptions), options.signal, () => options.session.abort(), 'Agent run was canceled.'), timeoutMs, options.timeoutMessage?.(timeoutMs) ?? `Agent execution timeout after ${timeoutMs / 1000} seconds`);
-        },
-    });
-    if (lastPromptError)
-        throw lastPromptError;
-    const handledProxyFallback = await runMindosAskProxyFallback({
-        phase: 'after-stream',
-        provider: options.provider,
-        baseUrl: options.baseUrl,
-        effectiveBaseUrlKey,
-        hasContent,
-        lastModelError,
-        send: options.send,
-        messages: options.proxyMessages,
-        runFallback: options.runFallback,
-        writeCompat: options.writeCompat,
-    });
-    if (!handledProxyFallback)
-        options.send({ type: 'done' });
-    return { hasContent, lastModelError };
-}
-function reportMindosExtensionLoadErrors(resourceLoader, onExtensionLoadErrors) {
-    let errors = [];
-    try {
-        errors = resourceLoader.getExtensions?.().errors ?? [];
-    }
-    catch {
-        return; // diagnostics must never break session setup
-    }
-    if (errors.length === 0)
-        return;
-    if (onExtensionLoadErrors) {
-        onExtensionLoadErrors(errors);
-        return;
-    }
-    for (const entry of errors) {
-        console.error(`[mindos] extension failed to load: ${entry.path}: ${entry.error}`);
-    }
-}
-export async function createMindosPiAgentRuntime(options) {
-    const lastMessage = options.messages.length > 0 ? options.messages[options.messages.length - 1] : undefined;
-    const lastUserContent = lastMessage?.role === 'user' ? lastMessage.content : '';
-    const lastUserSkillName = lastMessage?.role === 'user' && typeof lastMessage.skillName === 'string'
-        ? lastMessage.skillName
-        : undefined;
-    const lastUserImages = extractMindosUserImages(lastMessage);
-    const modelConfig = options.services.resolveModelConfig({
-        providerOverride: options.providerOverride,
-        modelOverride: options.modelOverride,
-        messages: options.messages,
-        hasImages: hasMindosMessageImages(options.messages),
-    });
-    let systemPrompt = options.systemPrompt;
-    if (modelConfig.provider === 'ollama' && options.services.getOllamaContextWindow && options.services.estimateTokens && options.services.compactPrompt) {
-        const ollamaBase = modelConfig.baseUrl || 'http://localhost:11434/v1';
-        const contextWindow = await options.services.getOllamaContextWindow(ollamaBase, modelConfig.modelName);
-        const promptTokens = options.services.estimateTokens(systemPrompt);
-        const maxPromptTokens = contextWindow ? Math.floor(contextWindow * 0.7) : undefined;
-        options.services.onOllamaContext?.({ modelName: modelConfig.modelName, contextWindow, promptTokens, maxPromptTokens });
-        if (maxPromptTokens && promptTokens > maxPromptTokens) {
-            systemPrompt = options.services.compactPrompt(systemPrompt, {
-                maxPromptTokens,
-                estimateTokens: options.services.estimateTokens,
-                onStrip: options.services.onOllamaCompactStrip,
-            });
-            options.services.onOllamaCompacted?.({
-                beforeTokens: promptTokens,
-                afterTokens: options.services.estimateTokens(systemPrompt),
-            });
-        }
-    }
-    const agentMessages = toMindosAgentMessages(options.messages);
-    const historyMessages = agentMessages.slice(0, -1);
-    const llmHistoryMessages = options.services.convertToLlm(historyMessages);
-    options.services.setKbMode(options.mode);
-    const authStorage = options.services.createAuthStorage();
-    authStorage.setRuntimeApiKey(options.services.toRuntimeProvider(modelConfig.provider), modelConfig.apiKey);
-    const modelRegistry = options.services.createModelRegistry(authStorage);
-    const settingsManager = options.services.createSettingsManager(createMindosPiSettingsConfig(options.agentConfig, modelConfig.provider));
-    const coreSkillNames = new Set(['mindos', 'mindos-zh', 'mindos-max', 'mindos-max-zh']);
-    // Agent-mode skill-index additions are discovered only after the first
-    // reload(), but the loader captured `systemPrompt` at construction. The
-    // override below re-applies the suffix on every reload, so the streaming
-    // session sees the available-skill index. Turn-local active skill requests
-    // belong in the latest user/context prompt, not in system identity.
-    let agentPromptSuffix = '';
-    const resourceLoader = options.services.createResourceLoader({
-        cwd: options.projectRoot,
-        agentDir: options.agentDir,
-        settingsManager,
-        systemPrompt,
-        systemPromptOverride: (base) => (agentPromptSuffix ? `${base ?? ''}${agentPromptSuffix}` : base),
-        appendSystemPrompt: [],
-        agentsFilesOverride: (result) => ({ ...result, agentsFiles: [] }),
-        skillsOverride: (result) => ({
-            ...result,
-            skills: result.skills.filter((skill) => !coreSkillNames.has(skill.name)),
-        }),
-        additionalSkillPaths: options.additionalSkillPaths ?? [],
-        additionalExtensionPaths: options.additionalExtensionPaths ?? [],
-    });
-    await resourceLoader.reload();
-    reportMindosExtensionLoadErrors(resourceLoader, options.services.onExtensionLoadErrors);
-    if (options.mode === 'agent') {
-        const disabledSkillNames = new Set(options.serverSettings?.disabledSkills ?? []);
-        const discoveredSkills = resourceLoader.getSkills?.().skills ?? [];
-        const thirdPartySkills = discoveredSkills.filter((skill) => !coreSkillNames.has(skill.name) && !skill.disableModelInvocation && !disabledSkillNames.has(skill.name));
-        if (thirdPartySkills.length > 0 && options.services.generateSkillsXml) {
-            agentPromptSuffix += `\n\n---\n\n${options.services.generateSkillsXml(thirdPartySkills)}`;
-        }
-        if (agentPromptSuffix) {
-            // Keep the returned prompt (used by the non-streaming fallback) in sync
-            // with what the streaming session sees via the override.
-            systemPrompt += agentPromptSuffix;
-            await resourceLoader.reload();
-            reportMindosExtensionLoadErrors(resourceLoader, options.services.onExtensionLoadErrors);
-        }
-    }
-    const sessionManager = options.services.createSessionManager();
-    for (const message of llmHistoryMessages) {
-        sessionManager.appendMessage(message);
-    }
-    const { session } = await options.services.createAgentSession({
-        cwd: options.projectRoot,
-        model: modelConfig.model,
-        thinkingLevel: options.agentConfig?.enableThinking && modelConfig.provider === 'anthropic' ? 'medium' : 'off',
-        authStorage,
-        modelRegistry,
-        resourceLoader,
-        sessionManager,
-        settingsManager,
-        // Builtin read/edit/write/bash stay off: KB file access must flow through
-        // the extension-registered KB tools (write-protection + audit log). The
-        // project-root bash tool is the only SDK customTool, and only when the
-        // request permission policy allows terminal access. options.requestTools is
-        // intentionally NOT passed here — SDK
-        // customTools override extension-registered tools by name, which would
-        // strip the kb-extension wrappers; requestTools is still used by the
-        // non-streaming proxy fallback and exposed on the returned runtime.
-        noTools: 'builtin',
-        customTools: options.mode === 'agent' && options.allowProjectBash !== false ? [options.bashTool] : [],
-    });
-    const fallbackTools = collectMindosRuntimeToolsForFallback({
-        requestTools: options.requestTools,
-        resourceLoader,
-        extensionContext: createMindosHeadlessExtensionContext({
-            cwd: options.projectRoot,
-            model: modelConfig.model,
-            modelRegistry,
-            sessionManager,
-            settingsManager,
-            resourceLoader,
-        }),
-    });
-    return {
-        session,
-        agentRunContextResource: sessionManager,
-        llmHistoryMessages,
-        requestTools: fallbackTools,
-        systemPrompt,
-        model: modelConfig.model,
-        modelName: modelConfig.modelName,
-        apiKey: modelConfig.apiKey,
-        provider: modelConfig.provider,
-        baseUrl: modelConfig.baseUrl,
-        lastUserContent,
-        lastUserImages,
-        lastUserSkillName,
-    };
-}
-function createMindosHeadlessExtensionContext(input) {
-    return {
-        cwd: input.cwd,
-        hasUI: false,
-        model: input.model,
-        modelRegistry: input.modelRegistry,
-        sessionManager: input.sessionManager,
-        settingsManager: input.settingsManager,
-        resourceLoader: input.resourceLoader,
-        ui: {
-            notify: () => { },
-            setWidget: () => { },
-            custom: async () => undefined,
-        },
-    };
-}
-function collectMindosRuntimeToolsForFallback(input) {
-    const byName = new Map();
-    for (const tool of input.requestTools) {
-        if (tool.name)
-            byName.set(tool.name, tool);
-    }
-    let extensions = [];
-    try {
-        extensions = input.resourceLoader.getExtensions?.().extensions ?? [];
-    }
-    catch {
-        return [...byName.values()];
-    }
-    for (const extension of extensions) {
-        for (const [entryName, rawTool] of mindosExtensionToolEntries(extension.tools)) {
-            const tool = mindosExtensionToolDefinition(rawTool);
-            if (!tool)
-                continue;
-            const name = typeof tool.name === 'string' ? tool.name : entryName;
-            if (!name || byName.has(name) || typeof tool.execute !== 'function')
-                continue;
-            byName.set(name, createMindosExecutableToolFromExtension(name, tool, input.extensionContext));
-        }
-    }
-    return [...byName.values()];
-}
-function mindosExtensionToolEntries(tools) {
-    if (!tools)
-        return [];
-    if (tools instanceof Map) {
-        return [...tools.entries()].map(([name, tool]) => [
-            typeof name === 'string' ? name : undefined,
-            tool,
-        ]);
-    }
-    if (Array.isArray(tools)) {
-        return tools.map((tool) => [
-            isRecord(tool) && typeof tool.name === 'string' ? tool.name : undefined,
-            tool,
-        ]);
-    }
-    if (isRecord(tools)) {
-        return Object.entries(tools).map(([name, tool]) => [name, tool]);
-    }
-    return [];
-}
-function mindosExtensionToolDefinition(rawTool) {
-    if (!isRecord(rawTool))
-        return null;
-    const wrappedDefinition = rawTool.definition;
-    if (isRecord(wrappedDefinition))
-        return wrappedDefinition;
-    return rawTool;
-}
-function createMindosExecutableToolFromExtension(name, tool, extensionContext) {
-    const execute = tool.execute;
-    const prepareArguments = typeof tool.prepareArguments === 'function'
-        ? tool.prepareArguments
-        : undefined;
-    return {
-        name,
-        description: typeof tool.description === 'string' ? tool.description : undefined,
-        parameters: tool.parameters,
-        execute: async (toolCallId, args, signal, onUpdate) => {
-            const preparedArgs = prepareArguments ? prepareArguments(args) : args;
-            const result = await execute.call(tool, toolCallId, preparedArgs, signal, onUpdate, extensionContext);
-            return normalizeMindosExecutableToolResult(result);
-        },
-    };
-}
-function normalizeMindosExecutableToolResult(result) {
-    if (isRecord(result) && Array.isArray(result.content)) {
-        return {
-            content: result.content
-                .filter(isRecord)
-                .map((part) => ({
-                type: typeof part.type === 'string' ? part.type : 'text',
-                ...(typeof part.text === 'string' ? { text: part.text } : {}),
-            })),
-        };
-    }
-    if (typeof result === 'string')
-        return { content: [{ type: 'text', text: result }] };
-    if (result == null)
-        return { content: [] };
-    return { content: [{ type: 'text', text: stringifyMindosToolResult(result) }] };
-}
-function stringifyMindosToolResult(result) {
-    try {
-        return JSON.stringify(result);
-    }
-    catch {
-        return String(result);
-    }
-}
-function createMindosPiSettingsConfig(agentConfig = {}, provider) {
-    return {
-        enableSkillCommands: true,
-        ...(agentConfig.enableThinking && provider === 'anthropic'
-            ? { thinkingBudgets: { medium: agentConfig.thinkingBudget ?? 5000 } }
-            : {}),
-        ...(agentConfig.contextStrategy === 'off' ? { compaction: { enabled: false } } : {}),
-    };
-}
-function hasMindosMessageImages(messages) {
-    return messages.some((message) => (extractMindosUserImages(message)?.length ?? 0) > 0);
-}
-function extractMindosUserImages(message) {
-    if (!message || message.role !== 'user')
-        return undefined;
-    const images = message.images?.filter((image) => image.data);
-    return images && images.length > 0 ? images : undefined;
-}
-export async function runMindosAskProxyFallback(options) {
-    if (options.phase === 'before-stream') {
-        if (options.compatMode !== 'non-streaming' || !isOpenAiCompatibleProxy(options))
-            return false;
-        options.send({ type: 'status', message: options.messages.proxyCompatMode });
-        try {
-            await options.runFallback();
-            options.send({ type: 'done' });
-        }
-        catch (error) {
-            options.send({ type: 'error', message: options.messages.proxyCompatFailed(errorMessage(error)) });
-        }
-        return true;
-    }
-    if (options.hasContent)
-        return false;
-    if (!options.lastModelError && !isOpenAiCompatibleProxy(options))
-        return false;
-    if (isOpenAiCompatibleProxy(options)) {
-        options.send({
-            type: 'status',
-            message: options.lastModelError ? options.messages.proxyCompatDetecting : options.messages.proxyCompatMode,
-        });
-        try {
-            await options.runFallback();
-            options.writeCompat?.(options.effectiveBaseUrlKey ?? options.baseUrl ?? 'default', 'non-streaming');
-            options.send({ type: 'done' });
-        }
-        catch (error) {
-            options.send({ type: 'error', message: options.messages.proxyCompatAlsoFailed(errorMessage(error)) });
-        }
-        return true;
-    }
-    if (options.lastModelError) {
-        options.send({ type: 'error', message: options.lastModelError });
-        return true;
-    }
-    return false;
-}
-function isOpenAiCompatibleProxy(options) {
-    return !!options.baseUrl && options.provider === 'openai';
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-export function buildMindosCompatEndpointCandidates(baseUrl, endpointPath, apiType) {
-    const base = baseUrl.replace(/\/+$/, '');
-    const cleanPath = endpointPath.startsWith('/') ? endpointPath : `/${endpointPath}`;
-    const hasVersionPrefix = /\/v\d+(?:$|\/)/.test(base);
-    const candidates = new Set();
-    candidates.add(`${base}${cleanPath}`);
-    if (!hasVersionPrefix && (apiType === 'openai-completions'
-        || apiType === 'openai-responses'
-        || apiType === 'anthropic-messages')) {
-        candidates.add(`${base}/v1${cleanPath}`);
-    }
-    return Array.from(candidates);
-}
-export function reassembleMindosOpenAISse(sseText) {
-    const lines = sseText.split('\n');
-    let content = '';
-    let role = 'assistant';
-    let finishReason = 'stop';
-    const toolCalls = new Map();
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith('data:'))
-            continue;
-        const payload = trimmed.slice(5).trim();
-        if (payload === '[DONE]')
-            break;
-        const chunk = parseUnknownJson(payload);
-        if (!isRecord(chunk))
-            continue;
-        const choices = Array.isArray(chunk.choices) ? chunk.choices : [];
-        const firstChoice = choices[0];
-        if (!isRecord(firstChoice))
-            continue;
-        const delta = firstChoice.delta;
-        if (!isRecord(delta))
-            continue;
-        if (typeof delta.role === 'string')
-            role = delta.role;
-        if (typeof delta.content === 'string')
-            content += delta.content;
-        if (typeof firstChoice.finish_reason === 'string')
-            finishReason = firstChoice.finish_reason;
-        if (Array.isArray(delta.tool_calls)) {
-            for (const rawToolCall of delta.tool_calls) {
-                if (!isRecord(rawToolCall))
-                    continue;
-                const toolCall = rawToolCall;
-                const idx = typeof toolCall.index === 'number' ? toolCall.index : 0;
-                const existing = toolCalls.get(idx);
-                if (!existing) {
-                    toolCalls.set(idx, {
-                        id: toolCall.id ?? '',
-                        type: toolCall.type ?? 'function',
-                        function: {
-                            name: toolCall.function?.name ?? '',
-                            arguments: toolCall.function?.arguments ?? '',
-                        },
-                    });
-                }
-                else {
-                    if (toolCall.id)
-                        existing.id = toolCall.id;
-                    if (toolCall.function?.name)
-                        existing.function.name += toolCall.function.name;
-                    if (toolCall.function?.arguments)
-                        existing.function.arguments += toolCall.function.arguments;
-                }
-            }
-        }
-    }
-    const message = { role, content: content || null };
-    if (toolCalls.size > 0)
-        message.tool_calls = Array.from(toolCalls.values());
-    return {
-        choices: [{ message, finish_reason: finishReason }],
-    };
-}
-export function mindosPiMessagesToOpenAI(piMessages) {
-    return piMessages
-        .map((message) => {
-        if (!isRecord(message))
-            return null;
-        const role = message.role;
-        if (role === 'system')
-            return null;
-        if (role === 'user') {
-            return {
-                role: 'user',
-                content: typeof message.content === 'string' ? message.content : message.content,
-            };
-        }
-        if (role === 'assistant') {
-            const assistantContent = message.content;
-            let textContent = '';
-            const toolCalls = [];
-            if (Array.isArray(assistantContent)) {
-                for (const rawPart of assistantContent) {
-                    if (!isRecord(rawPart))
-                        continue;
-                    if (rawPart.type === 'text' && typeof rawPart.text === 'string') {
-                        textContent += rawPart.text;
-                    }
-                    else if (rawPart.type === 'toolCall') {
-                        toolCalls.push({
-                            id: typeof rawPart.id === 'string' ? rawPart.id : `call_${Date.now()}`,
-                            type: 'function',
-                            function: {
-                                name: typeof rawPart.name === 'string' ? rawPart.name : 'unknown',
-                                arguments: JSON.stringify(rawPart.arguments ?? {}),
-                            },
-                        });
-                    }
-                }
-            }
-            const result = { role: 'assistant', content: textContent || '' };
-            if (toolCalls.length > 0)
-                result.tool_calls = toolCalls;
-            return result;
-        }
-        if (role === 'toolResult') {
-            const contentText = Array.isArray(message.content)
-                ? message.content
-                    .filter((part) => isRecord(part) && part.type === 'text')
-                    .map((part) => part.text ?? '')
-                    .join('\n')
-                : String(message.content ?? '');
-            return {
-                role: 'tool',
-                tool_call_id: typeof message.toolCallId === 'string' ? message.toolCallId : 'unknown',
-                content: contentText,
-            };
-        }
-        return null;
-    })
-        .filter((message) => message !== null);
-}
-export async function runMindosNonStreamingFallback(options) {
-    const { baseUrl, apiKey, model, systemPrompt, historyMessages, userContent, tools, send, signal, maxSteps, } = options;
-    const fetchImpl = options.fetch ?? fetch;
-    const chunkDelayMs = options.chunkDelayMs ?? 8;
-    const openaiTools = tools.map((tool) => ({
-        type: 'function',
-        function: {
-            name: tool.name,
-            description: tool.description ?? '',
-            parameters: tool.parameters ?? { type: 'object', properties: {} },
-        },
-    }));
-    const messages = [
-        { role: 'system', content: systemPrompt },
-        ...mindosPiMessagesToOpenAI(historyMessages),
-        { role: 'user', content: userContent },
-    ];
-    const toolMap = new Map(tools.map((tool) => [tool.name, tool]));
-    const endpoints = buildMindosCompatEndpointCandidates(baseUrl, '/chat/completions', 'openai-completions');
-    let step = 0;
-    while (step < maxSteps) {
-        if (signal.aborted)
-            throw new Error('Request aborted');
-        step += 1;
-        let response = null;
-        let lastEndpointError = '';
-        for (const endpoint of endpoints) {
-            const attempt = await fetchImpl(endpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${apiKey}`,
-                },
-                body: JSON.stringify({
-                    model,
-                    messages,
-                    tools: openaiTools.length > 0 ? openaiTools : undefined,
-                    tool_choice: openaiTools.length > 0 ? 'auto' : undefined,
-                    stream: true,
-                }),
-                signal,
-            });
-            if (attempt.ok) {
-                response = attempt;
-                break;
-            }
-            const errorText = await attempt.text().catch(() => '');
-            lastEndpointError = `HTTP ${attempt.status} @ ${endpoint}: ${errorText.slice(0, 200)}`;
-            if (attempt.status !== 404) {
-                throw new Error(`Non-streaming API error ${lastEndpointError}`);
-            }
-        }
-        if (!response) {
-            throw new Error(`Non-streaming API error ${lastEndpointError || 'all endpoint candidates failed'}; tried ${endpoints.length} endpoint candidate(s)`);
-        }
-        const rawText = await response.text();
-        const trimmed = rawText.trimStart();
-        const data = trimmed.startsWith('data:')
-            ? reassembleMindosOpenAISse(trimmed)
-            : parseUnknownJson(rawText);
-        if (!isRecord(data)) {
-            throw new Error(`API returned invalid response: ${rawText.slice(0, 200)}`);
-        }
-        const choices = Array.isArray(data.choices) ? data.choices : [];
-        const choice = choices[0];
-        if (!isRecord(choice))
-            throw new Error('Empty response from API');
-        const message = isRecord(choice.message) ? choice.message : isRecord(choice.delta) ? choice.delta : {};
-        const finishReason = typeof choice.finish_reason === 'string' ? choice.finish_reason : 'stop';
-        if (typeof message.content === 'string' && message.content) {
-            const chunkSize = 40;
-            for (let i = 0; i < message.content.length; i += chunkSize) {
-                send({ type: 'text_delta', delta: message.content.slice(i, i + chunkSize) });
-                if (chunkDelayMs > 0)
-                    await new Promise((resolveDelay) => setTimeout(resolveDelay, chunkDelayMs));
-            }
-        }
-        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
-        if (finishReason === 'stop' || toolCalls.length === 0)
-            break;
-        const toolResultMessages = [];
-        for (const rawToolCall of toolCalls) {
-            if (!isRecord(rawToolCall))
-                continue;
-            const functionCall = isRecord(rawToolCall.function) ? rawToolCall.function : {};
-            const toolName = typeof functionCall.name === 'string' ? functionCall.name : '';
-            const toolCallId = typeof rawToolCall.id === 'string' ? rawToolCall.id : `call_${Date.now()}`;
-            const parsedArgs = safeParseMindosJsonObject(typeof functionCall.arguments === 'string' ? functionCall.arguments : '{}');
-            const tool = toolMap.get(toolName);
-            send({ type: 'tool_start', toolCallId, toolName, args: sanitizeToolArgs(toolName, parsedArgs) });
-            let resultText = '';
-            let isError = false;
-            if (tool) {
-                try {
-                    const result = await tool.execute(toolCallId, parsedArgs, signal, (update) => {
-                        const delta = getMindosToolUpdateText(update);
-                        if (delta)
-                            send({ type: 'tool_delta', toolCallId, toolName, delta: sanitizeToolOutput(delta) });
-                    });
-                    resultText = result.content
-                        .filter((part) => part.type === 'text')
-                        .map((part) => part.text ?? '')
-                        .join('\n');
-                }
-                catch (error) {
-                    resultText = errorMessage(error);
-                    isError = true;
-                }
-            }
-            else {
-                resultText = `Tool "${toolName}" not found`;
-                isError = true;
-            }
-            send({ type: 'tool_end', toolCallId, toolName, output: sanitizeToolOutput(resultText), isError });
-            toolResultMessages.push({ role: 'tool', tool_call_id: toolCallId, content: resultText });
-        }
-        messages.push({
-            role: 'assistant',
-            content: message.content ?? null,
-            tool_calls: message.tool_calls,
-        });
-        messages.push(...toolResultMessages);
-    }
-}
-function getMindosToolUpdateText(update) {
-    if (!isRecord(update) || !Array.isArray(update.content))
-        return '';
-    return update.content
-        .filter(isRecord)
-        .filter((part) => part.type === 'text' || part.type === undefined)
-        .map((part) => (typeof part.text === 'string' ? part.text : ''))
-        .filter(Boolean)
-        .join('\n');
-}
-function parseUnknownJson(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-export function detectMindosAgentLoop(history, threshold = 3) {
-    if (history.length < threshold)
-        return false;
-    const lastN = history.slice(-threshold);
-    if (lastN.every((step) => step.tool === lastN[0]?.tool && step.input === lastN[0]?.input)) {
-        return true;
-    }
-    if (history.length >= 4) {
-        const window = history.slice(-8);
-        for (let cycleLen = 2; cycleLen <= 4 && cycleLen * 2 <= window.length; cycleLen += 1) {
-            const tail = window.slice(-cycleLen * 2);
-            let toolsMatch = true;
-            let anyArgsMatch = false;
-            for (let i = 0; i < cycleLen; i += 1) {
-                const left = tail[i];
-                const right = tail[i + cycleLen];
-                if (!left || !right || left.tool !== right.tool) {
-                    toolsMatch = false;
-                    break;
-                }
-                if (left.input === right.input)
-                    anyArgsMatch = true;
-            }
-            if (toolsMatch && anyArgsMatch)
-                return true;
-        }
-    }
-    return false;
-}
-export function toMindosAgentMessages(messages) {
-    const result = [];
-    for (const msg of messages) {
-        const timestamp = msg.timestamp ?? Date.now();
-        if (msg.role === 'user') {
-            result.push({
-                role: 'user',
-                content: buildMindosUserContent(msg.content, msg.images),
-                timestamp,
-            });
-            continue;
-        }
-        if (msg.content.startsWith('__error__'))
-            continue;
-        if (!msg.parts || msg.parts.length === 0) {
-            if (msg.content) {
-                result.push(createMindosAssistantHistoryMessage({
-                    content: [{ type: 'text', text: msg.content }],
-                    stopReason: 'stop',
-                    timestamp,
-                }));
-            }
-            continue;
-        }
-        const assistantContent = [];
-        const toolCalls = [];
-        for (const part of msg.parts) {
-            if (part.type === 'text') {
-                if (part.text)
-                    assistantContent.push({ type: 'text', text: part.text });
-            }
-            else if (part.type === 'tool-call') {
-                assistantContent.push({
-                    type: 'toolCall',
-                    id: part.toolCallId,
-                    name: part.toolName,
-                    arguments: part.input ?? {},
-                });
-                toolCalls.push(part);
-            }
-            else if (part.type === 'runtime-status') {
-                // UI-only runtime diagnostics should not become model conversation history.
-            }
-        }
-        if (assistantContent.length > 0) {
-            result.push(createMindosAssistantHistoryMessage({
-                content: assistantContent,
-                stopReason: toolCalls.length > 0 ? 'toolUse' : 'stop',
-                timestamp,
-            }));
-        }
-        for (const toolCall of toolCalls) {
-            result.push({
-                role: 'toolResult',
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                content: [{ type: 'text', text: toolCall.output ?? '' }],
-                isError: toolCall.state === 'error',
-                timestamp,
-            });
-        }
-    }
-    return result;
-}
-function buildMindosUserContent(text, images) {
-    const validImages = images?.filter((image) => image.data);
-    if (!validImages || validImages.length === 0)
-        return text;
-    const parts = validImages.map((image) => ({
-        type: 'image',
-        data: image.data,
-        mimeType: image.mimeType,
-    }));
-    if (text)
-        parts.push({ type: 'text', text });
-    return parts;
-}
-function createMindosAssistantHistoryMessage(input) {
-    return {
-        role: 'assistant',
-        content: input.content,
-        api: 'anthropic-messages',
-        provider: 'anthropic',
-        model: '',
-        usage: {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            totalTokens: 0,
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        },
-        stopReason: input.stopReason,
-        timestamp: input.timestamp,
-    };
-}
-export { detectMindosAgentLoop as detectLoop, isMindosRetryableError as isRetryableError, isMindosTransientError as isTransientError, mindosRetryDelay as retryDelay, sleepMindos as sleep, };
+export * from '../agent/session/index.js';
 //# sourceMappingURL=index.js.map