@geminilight/mindos 1.1.25 → 1.1.28

package/dist/agent/selected-skills.d.ts

@@ -0,0 +1,8 @@
+export type MindosSelectedSkillSource = 'user-selected' | 'implicit';
+export type MindosSelectedSkill = {
+    name: string;
+    source?: MindosSelectedSkillSource;
+};
+export declare function normalizeMindosSelectedSkills(skills: Array<MindosSelectedSkill | string | null | undefined> | undefined, legacySkillName?: string): MindosSelectedSkill[];
+export declare function mindosSelectedSkillNames(skills: Array<MindosSelectedSkill | string | null | undefined> | undefined): string[];
+//# sourceMappingURL=selected-skills.d.ts.map

package/dist/agent/selected-skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selected-skills.d.ts","sourceRoot":"","sources":["../../src/agent/selected-skills.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,yBAAyB,GAAG,eAAe,GAAG,UAAU,CAAC;AAErE,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,yBAAyB,CAAC;CACpC,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,KAAK,CAAC,mBAAmB,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,SAAS,EAC1E,eAAe,CAAC,EAAE,MAAM,GACvB,mBAAmB,EAAE,CAqBvB;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC,mBAAmB,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,SAAS,GAAG,MAAM,EAAE,CAE7H"}

package/dist/agent/selected-skills.js

@@ -0,0 +1,27 @@
+export function normalizeMindosSelectedSkills(skills, legacySkillName) {
+    const result = [];
+    const seen = new Set();
+    const add = (value, fallbackSource) => {
+        const name = typeof value === 'string'
+            ? value.trim()
+            : (value?.name ?? '').trim();
+        if (!name || seen.has(name))
+            return;
+        seen.add(name);
+        const source = typeof value === 'string'
+            ? fallbackSource
+            : (value?.source ?? fallbackSource);
+        result.push({
+            name,
+            source,
+        });
+    };
+    for (const skill of skills ?? [])
+        add(skill, 'user-selected');
+    add(legacySkillName, 'user-selected');
+    return result;
+}
+export function mindosSelectedSkillNames(skills) {
+    return normalizeMindosSelectedSkills(skills).map((skill) => skill.name);
+}
+//# sourceMappingURL=selected-skills.js.map

package/dist/agent/selected-skills.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selected-skills.js","sourceRoot":"","sources":["../../src/agent/selected-skills.ts"],"names":[],"mappings":"AAOA,MAAM,UAAU,6BAA6B,CAC3C,MAA0E,EAC1E,eAAwB;IAExB,MAAM,MAAM,GAA0B,EAAE,CAAC;IACzC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,GAAG,GAAG,CAAC,KAAsD,EAAE,cAAyC,EAAE,EAAE;QAChH,MAAM,IAAI,GAAG,OAAO,KAAK,KAAK,QAAQ;YACpC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE;YACd,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QAC/B,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO;QACpC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACf,MAAM,MAAM,GAAG,OAAO,KAAK,KAAK,QAAQ;YACtC,CAAC,CAAC,cAAc;YAChB,CAAC,CAAC,CAAC,KAAK,EAAE,MAAM,IAAI,cAAc,CAAC,CAAC;QACtC,MAAM,CAAC,IAAI,CAAC;YACV,IAAI;YACJ,MAAM;SACP,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,KAAK,MAAM,KAAK,IAAI,MAAM,IAAI,EAAE;QAAE,GAAG,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;IAC9D,GAAG,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;IACtC,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,MAA0E;IACjH,OAAO,6BAA6B,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAC1E,CAAC"}

package/dist/agent/session/index.d.ts

@@ -0,0 +1,618 @@
+import type { MindosDiscoveredSkill, MindosExtensionLoadError, MindosPiResourceLoaderAdapter } from '../mindos-pi/resource-types.js';
+import type { MindosExecutableTool } from '../tool/executable-tool.js';
+export { redactSensitiveObject, redactSensitiveText } from './redaction.js';
+export type { MindosDiscoveredSkill, MindosExtensionEntry, MindosExtensionLoadError, MindosExtensionLoadResult, MindosPiResourceLoaderAdapter, } from '../mindos-pi/resource-types.js';
+export type { MindosExecutableTool } from '../tool/executable-tool.js';
+export type MindosSessionEventType = 'session.started' | 'message.delta' | 'tool.started' | 'tool.completed' | 'session.completed' | 'session.failed';
+export type MindosSessionEvent<TData = unknown> = {
+    id: string;
+    type: MindosSessionEventType;
+    sessionId: string;
+    timestamp: string;
+    data?: TData;
+};
+export type MindosSessionStreamSchema = {
+    protocol: 'mindos.session.events';
+    version: 1;
+    events: MindosSessionEventType[];
+};
+export declare const MINDOS_SESSION_STREAM_SCHEMA: MindosSessionStreamSchema;
+export declare function createMindosSessionEvent<TData>(input: Omit<MindosSessionEvent<TData>, 'timestamp'> & {
+    timestamp?: string;
+}): MindosSessionEvent<TData>;
+export type MindOSSSEvent = {
+    type: 'agent_run_context';
+    rootRunId: string;
+    chatSessionId?: string;
+    startedAt: number;
+} | {
+    type: 'text_delta';
+    delta: string;
+} | {
+    type: 'thinking_delta';
+    delta: string;
+} | {
+    type: 'tool_start';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    runtime?: 'mindos' | 'acp' | 'codex' | 'claude';
+} | {
+    type: 'tool_delta';
+    toolCallId: string;
+    delta: string;
+    toolName?: string;
+    runtime?: 'mindos' | 'acp' | 'codex' | 'claude';
+} | {
+    type: 'tool_end';
+    toolCallId: string;
+    output: string;
+    isError: boolean;
+    toolName?: string;
+    runtime?: 'mindos' | 'acp' | 'codex' | 'claude';
+} | {
+    type: 'runtime_permission_request';
+    runId: string;
+    requestId: string;
+    runtime: 'codex' | 'claude';
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    options: Array<{
+        id: string;
+        label: string;
+        description?: string;
+        intent?: 'allow' | 'deny' | 'cancel';
+        scope?: 'once' | 'session' | 'always' | 'turn';
+    }>;
+    reason?: string;
+    action?: string;
+    resource?: string;
+    risk?: {
+        level: 'low' | 'medium' | 'high';
+        summary: string;
+        reasons?: string[];
+    };
+} | {
+    type: 'runtime_permission_resolved';
+    runId: string;
+    requestId: string;
+    runtime: 'codex' | 'claude';
+    toolCallId: string;
+    decision: string;
+    cancelled?: boolean;
+    decisionLabel?: string;
+    decisionIntent?: 'allow' | 'deny' | 'cancel';
+    decisionScope?: 'once' | 'session' | 'always' | 'turn';
+} | {
+    type: 'user_question_start';
+    runId: string;
+    toolCallId: string;
+    questions: unknown;
+} | {
+    type: 'user_question_answered';
+    runId: string;
+    toolCallId: string;
+    answers?: unknown;
+} | {
+    type: 'user_question_cancelled';
+    runId: string;
+    toolCallId: string;
+    reason: string;
+} | {
+    type: 'runtime_binding';
+    runtime: 'acp' | 'codex' | 'claude';
+    externalSessionId: string;
+    cwd?: string;
+    status?: 'active' | 'missing' | 'signed-out' | 'archived' | 'failed';
+    reason?: string;
+} | {
+    type: 'done';
+    usage?: {
+        input: number;
+        output: number;
+    };
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'status';
+    message: string;
+    visible?: boolean;
+    runtime?: 'mindos' | 'acp' | 'codex' | 'claude';
+};
+export declare const MINDOS_ASK_STREAM_EVENT_TYPES: readonly ["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 declare const MINDOS_SSE_HEADERS: Record<string, string>;
+export type MessageUpdateEvent = {
+    type: 'message_update';
+    assistantMessageEvent?: {
+        type: string;
+        delta?: string;
+    };
+};
+export type ToolExecStartEvent = {
+    type: 'tool_execution_start';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+};
+export type ToolExecEndEvent = {
+    type: 'tool_execution_end';
+    toolCallId: string;
+    result?: {
+        content?: Array<{
+            type: string;
+            text?: string;
+        }>;
+    };
+    isError?: boolean;
+};
+export type TurnEndEvent = {
+    type: 'turn_end';
+    toolResults?: Array<{
+        toolName: string;
+        content: unknown;
+    }>;
+    usage?: {
+        inputTokens: number;
+        outputTokens?: number;
+    };
+};
+export type AgentEndEvent = {
+    type: 'agent_end';
+    messages?: Array<{
+        role: string;
+        content?: Array<{
+            type: string;
+            text?: string;
+        }>;
+        stopReason?: string;
+        errorMessage?: string;
+    }>;
+};
+export declare function isTextDeltaEvent(event: unknown): event is MessageUpdateEvent;
+export declare function getTextDelta(event: unknown): string;
+export declare function isThinkingDeltaEvent(event: unknown): event is MessageUpdateEvent;
+export declare function getThinkingDelta(event: unknown): string;
+export declare function isToolExecutionStartEvent(event: unknown): event is ToolExecStartEvent;
+export declare function getToolExecutionStart(event: unknown): {
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+};
+export declare function isToolExecutionEndEvent(event: unknown): event is ToolExecEndEvent;
+export declare function getToolExecutionEnd(event: unknown): {
+    toolCallId: string;
+    output: string;
+    isError: boolean;
+};
+export declare function isTurnEndEvent(event: unknown): event is TurnEndEvent;
+export declare function getTurnEndData(event: unknown): {
+    toolResults: Array<{
+        toolName: string;
+        content: unknown;
+    }>;
+};
+export type MindosAgentEventReducerOptions = {
+    stepLimit: number;
+    loopWarningMessage?: string;
+};
+export type MindosAgentEventEffect = {
+    events: MindOSSSEvent[];
+    hasVisibleContent: boolean;
+    toolExecutions?: number;
+    tokenUsage?: {
+        input: number;
+        output: number;
+    };
+    stepCount?: number;
+    shouldAbort?: boolean;
+    steerMessage?: string;
+    lastModelError?: string;
+};
+export type MindosAgentEventReducer = {
+    readonly lastModelError: string;
+    readonly stepCount: number;
+    handle(event: unknown): MindosAgentEventEffect;
+};
+export declare function createMindosAgentEventReducer(options: MindosAgentEventReducerOptions): MindosAgentEventReducer;
+export declare function sanitizeToolArgs(toolName: string, args: unknown): unknown;
+export declare function sanitizeToolOutput(output: string): string;
+export declare function encodeMindosSseEvent(event: MindOSSSEvent): string;
+export declare function parseMindosSseLine(line: string): MindOSSSEvent | null;
+export type MindosAskMode = 'agent' | 'organize';
+export type MindosAskFileValidationResult = {
+    valid: boolean;
+    newCumulativeSize: number;
+    error?: string;
+};
+export type MindosAskFileContextServices = {
+    readFile(filePath: string): string;
+    truncate?: (content: string) => string;
+    validateFileSize?: (filePath: string, cumulativeSize: number) => MindosAskFileValidationResult;
+    warn?: (message: string, error?: unknown) => void;
+};
+export type MindosAskFileContext = {
+    contextParts: string[];
+    failedFiles: string[];
+};
+export declare function normalizeMindosAskMode(mode: unknown): MindosAskMode;
+export declare function normalizeMindosAskStepLimit(options: {
+    mode: MindosAskMode;
+    requestedMaxSteps?: unknown;
+    agentMaxSteps?: number;
+}): number;
+export declare function resolveMindosAgentTimeoutMs(raw?: string | undefined, defaultMs?: number): number;
+export declare function expandMindosAskAttachedFiles(raw: string[] | undefined, collectAllFiles: () => string[], maxDirFiles?: number): string[] | undefined;
+export declare function loadMindosAskFileContext(attachedFiles: string[] | undefined, currentFile: string | undefined, mode: string, services: MindosAskFileContextServices): MindosAskFileContext;
+export declare function createMindosUploadedFileParts(uploadedFiles: unknown, options?: {
+    maxBytes?: number;
+    limit?: number;
+}): string[];
+export type MindosExternalRuntimePromptInput = {
+    prompt: string;
+    mode?: MindosAskMode;
+    fileContext?: MindosAskFileContext;
+    uploadedParts?: string[];
+    recalledKnowledge?: Array<{
+        path: string;
+        content: string;
+    }>;
+};
+export declare function buildMindosExternalRuntimePrompt(input: MindosExternalRuntimePromptInput): string;
+export declare function safeParseMindosJsonObject(raw: string | undefined): Record<string, unknown>;
+export declare function dirnameOfMindosPath(filePath?: string): string | null;
+export type MindosAgentStepEntry = {
+    tool: string;
+    input: string;
+};
+export declare function isMindosTransientError(err: Error): boolean;
+export declare function isMindosRetryableError(err: unknown, httpStatus?: number): boolean;
+export declare function mindosRetryDelay(attempt: number): number;
+export declare function sleepMindos(ms: number, signal?: AbortSignal): Promise<void>;
+export type MindosAskRetryOptions = {
+    maxRetries?: number;
+    signal?: AbortSignal;
+    hasContent(): boolean;
+    onVisibleContent?(): void;
+    send(event: MindOSSSEvent): void;
+    execute(attempt: number): Promise<void>;
+    onAttemptError?(error: Error, attempt: number): Promise<void> | void;
+    isTransientError?: (error: Error) => boolean;
+    retryDelay?: (attempt: number) => number;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    retryMessage?: (attempt: number, maxRetries: number) => string;
+};
+export declare function runMindosAskWithRetry(options: MindosAskRetryOptions): Promise<Error | null>;
+export type MindosAcpSessionUpdate = {
+    type: string;
+    text?: string;
+    error?: string;
+    toolCall?: {
+        toolCallId: string;
+        title?: string;
+        kind?: string;
+        rawInput?: string;
+        rawOutput?: string;
+        status?: string;
+    };
+    plan?: {
+        entries?: Array<{
+            status?: string;
+            content?: string;
+        }>;
+    };
+};
+export type MindosAcpUpdateMappingOptions = {
+    suppressErrors?: boolean;
+};
+export declare function mapMindosAcpUpdateToSseEvents(update: MindosAcpSessionUpdate, options?: MindosAcpUpdateMappingOptions): {
+    events: MindOSSSEvent[];
+    hasVisibleContent: boolean;
+};
+export type MindosAcpAskSessionServices = {
+    createSession(agentId: string, options: {
+        cwd: string;
+        permissionMode?: 'agent' | 'readonly';
+    }): Promise<{
+        id: string;
+    }>;
+    promptStream(sessionId: string, prompt: string, onUpdate: (update: MindosAcpSessionUpdate) => void, signal?: AbortSignal): Promise<void>;
+    cancelPrompt?(sessionId: string): Promise<void>;
+    closeSession(sessionId: string): Promise<void>;
+};
+export type MindosAcpAskSessionOptions = MindosAcpAskSessionServices & {
+    agentId: string;
+    cwd: string;
+    prompt: string;
+    maxRetries?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    hasContent(): boolean;
+    onVisibleContent?(): void;
+    send(event: MindOSSSEvent): void;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    retryDelay?: (attempt: number) => number;
+    timeoutMessage?: (timeoutMs: number) => string;
+    errorMessage?: (error: Error) => string;
+};
+export type MindosAcpAskSessionResult = {
+    error?: Error;
+};
+export declare function runMindosAcpAskSession(options: MindosAcpAskSessionOptions): Promise<MindosAcpAskSessionResult>;
+export declare function runMindosWithTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T>;
+export type MindosPiAgentSessionAdapter = {
+    subscribe(callback: (event: unknown) => void): void;
+    prompt(prompt: string, options?: unknown): Promise<void>;
+    steer(message: string): Promise<void> | void;
+    abort(): Promise<void> | void;
+};
+export type MindosPiAgentAskSessionOptions = {
+    session: MindosPiAgentSessionAdapter;
+    prompt: string;
+    promptOptions?: unknown;
+    stepLimit: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    provider: string;
+    baseUrl?: string;
+    effectiveBaseUrlKey?: string;
+    compatMode?: string;
+    send(event: MindOSSSEvent): void;
+    runFallback(): Promise<void>;
+    proxyMessages: MindosAskProxyFallbackMessages;
+    writeCompat?(key: string, mode: 'non-streaming'): void;
+    onToolExecution?(): void;
+    onTokens?(input: number, output: number): void;
+    onStep?(step: number, stepLimit: number): void;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    retryDelay?: (attempt: number) => number;
+    timeoutMessage?: (timeoutMs: number) => string;
+};
+export type MindosPiAgentAskSessionResult = {
+    hasContent: boolean;
+    lastModelError: string;
+};
+export declare function runMindosPiAgentAskSession(options: MindosPiAgentAskSessionOptions): Promise<MindosPiAgentAskSessionResult>;
+export type MindosResolvedModelConfig = {
+    model: unknown;
+    modelName: string;
+    apiKey: string;
+    provider: string;
+    baseUrl?: string;
+};
+export type MindosPiRuntimeResourceLoaderConfig = {
+    cwd: string;
+    agentDir: string;
+    settingsManager: unknown;
+    systemPrompt: string;
+    /**
+     * Re-evaluated by the SDK loader on every reload(). The agent-mode system
+     * prompt suffix (skills XML + active-skill directive) is delivered through
+     * this hook — `systemPrompt` above is captured once at construction, so
+     * appending to it after the loader exists never reaches the session.
+     */
+    systemPromptOverride?(base?: string): string | undefined;
+    appendSystemPrompt: string[];
+    agentsFilesOverride(result: {
+        agentsFiles: unknown[];
+    }): {
+        agentsFiles: unknown[];
+    };
+    skillsOverride(result: {
+        skills: MindosDiscoveredSkill[];
+    }): {
+        skills: MindosDiscoveredSkill[];
+    };
+    additionalSkillPaths: string[];
+    additionalExtensionPaths: string[];
+};
+export type MindosPiRuntimeCreateAgentSessionConfig = {
+    cwd: string;
+    model: unknown;
+    thinkingLevel: 'medium' | 'off';
+    authStorage: unknown;
+    modelRegistry: unknown;
+    resourceLoader: MindosPiResourceLoaderAdapter;
+    sessionManager: unknown;
+    settingsManager: unknown;
+    /**
+     * pi-coding-agent ≥0.62 made `tools` a string-name ALLOWLIST that hard-filters
+     * every tool source (builtin + extension + custom). MindOS must never set it:
+     * extension-registered KB tools would be filtered out. Builtins stay off via
+     * `noTools: 'builtin'` and capabilities come from extensions + customTools.
+     */
+    noTools: 'builtin';
+    customTools: unknown[];
+};
+export type MindosPiSessionManagerAdapter = {
+    appendMessage(message: unknown): void;
+};
+export type MindosPiAgentRuntimeServices = {
+    resolveModelConfig(input: {
+        providerOverride?: string;
+        modelOverride?: string;
+        messages: MindosUiAskMessage[];
+        hasImages: boolean;
+    }): MindosResolvedModelConfig;
+    toRuntimeProvider(provider: string): string;
+    createAuthStorage(): {
+        setRuntimeApiKey(provider: string, apiKey: string): void;
+    };
+    createModelRegistry(authStorage: unknown): unknown;
+    createSettingsManager(settings: Record<string, unknown>): unknown;
+    createSessionManager(): MindosPiSessionManagerAdapter;
+    createResourceLoader(config: MindosPiRuntimeResourceLoaderConfig): MindosPiResourceLoaderAdapter;
+    createAgentSession(config: MindosPiRuntimeCreateAgentSessionConfig): Promise<{
+        session: MindosPiAgentSessionAdapter;
+    }>;
+    convertToLlm(messages: MindosAgentHistoryMessage[]): unknown[];
+    setKbMode(mode: MindosAskMode): void;
+    generateSkillsXml?(skills: MindosDiscoveredSkill[]): string;
+    getOllamaContextWindow?(baseUrl: string, modelName: string): Promise<number | undefined>;
+    estimateTokens?(content: string): number;
+    compactPrompt?(prompt: string, options: {
+        maxPromptTokens: number;
+        estimateTokens(content: string): number;
+        onStrip?(section: string, sectionTokens: number): void;
+    }): string;
+    onOllamaContext?(data: {
+        modelName: string;
+        contextWindow?: number;
+        promptTokens: number;
+        maxPromptTokens?: number;
+    }): void;
+    onOllamaCompactStrip?(section: string, sectionTokens: number): void;
+    onOllamaCompacted?(data: {
+        beforeTokens: number;
+        afterTokens: number;
+    }): void;
+    /**
+     * Called after each resource loader reload() that produced extension load
+     * errors. A failed extension entry silently drops every tool it would have
+     * registered (the session runs with `noTools: 'builtin'`), so hosts should
+     * at minimum log these. Defaults to console.error when not provided.
+     */
+    onExtensionLoadErrors?(errors: MindosExtensionLoadError[]): void;
+};
+export type MindosPiAgentRuntimeOptions = {
+    mode: MindosAskMode;
+    messages: MindosUiAskMessage[];
+    systemPrompt: string;
+    providerOverride?: string;
+    modelOverride?: string;
+    projectRoot: string;
+    agentDir: string;
+    mindRoot: string;
+    agentConfig?: {
+        enableThinking?: boolean;
+        thinkingBudget?: number;
+        contextStrategy?: string;
+    };
+    serverSettings?: {
+        disabledSkills?: string[];
+    };
+    additionalSkillPaths?: string[];
+    additionalExtensionPaths?: string[];
+    requestTools: MindosExecutableTool[];
+    allowProjectBash?: boolean;
+    bashTool: unknown;
+    services: MindosPiAgentRuntimeServices;
+};
+export type MindosPiAgentRuntime = {
+    session: MindosPiAgentSessionAdapter;
+    agentRunContextResource: object;
+    llmHistoryMessages: unknown[];
+    requestTools: MindosExecutableTool[];
+    systemPrompt: string;
+    model: unknown;
+    modelName: string;
+    apiKey: string;
+    provider: string;
+    baseUrl?: string;
+    lastUserContent: string;
+    lastUserImages?: MindosUiImagePart[];
+    lastUserSkillName?: string;
+};
+export declare function createMindosPiAgentRuntime(options: MindosPiAgentRuntimeOptions): Promise<MindosPiAgentRuntime>;
+export type MindosAskProxyFallbackMessages = {
+    proxyCompatMode: string;
+    proxyCompatDetecting: string;
+    proxyCompatFailed(message: string): string;
+    proxyCompatAlsoFailed(message: string): string;
+};
+export type MindosAskProxyFallbackOptions = {
+    phase: 'before-stream' | 'after-stream';
+    provider: string;
+    baseUrl?: string;
+    effectiveBaseUrlKey?: string;
+    compatMode?: string;
+    hasContent?: boolean;
+    lastModelError?: string;
+    send(event: MindOSSSEvent): void;
+    runFallback(): Promise<void>;
+    writeCompat?(key: string, mode: 'non-streaming'): void;
+    messages: MindosAskProxyFallbackMessages;
+};
+export declare function runMindosAskProxyFallback(options: MindosAskProxyFallbackOptions): Promise<boolean>;
+export declare function buildMindosCompatEndpointCandidates(baseUrl: string, endpointPath: string, apiType: string): string[];
+type MindosOpenAIMessage = {
+    role: string;
+    content?: unknown;
+    tool_calls?: unknown;
+    tool_call_id?: string;
+};
+type MindosOpenAIToolCall = {
+    id: string;
+    type: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+export declare function reassembleMindosOpenAISse(sseText: string): {
+    choices: Array<{
+        message: {
+            role: string;
+            content: string | null;
+            tool_calls?: MindosOpenAIToolCall[];
+        };
+        finish_reason: string;
+    }>;
+};
+export declare function mindosPiMessagesToOpenAI(piMessages: unknown[]): MindosOpenAIMessage[];
+export type MindosNonStreamingFallbackOptions = {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    systemPrompt: string;
+    historyMessages: unknown[];
+    userContent: string;
+    tools: MindosExecutableTool[];
+    send(event: MindOSSSEvent): void;
+    signal: AbortSignal;
+    maxSteps: number;
+    fetch?: typeof fetch;
+    chunkDelayMs?: number;
+};
+export declare function runMindosNonStreamingFallback(options: MindosNonStreamingFallbackOptions): Promise<void>;
+export declare function detectMindosAgentLoop(history: MindosAgentStepEntry[], threshold?: number): boolean;
+export type MindosUiImagePart = {
+    type: 'image';
+    data?: string;
+    mimeType?: string;
+};
+export type MindosUiTextPart = {
+    type: 'text';
+    text?: string;
+};
+export type MindosUiReasoningPart = {
+    type: 'reasoning';
+    text?: string;
+};
+export type MindosUiToolCallPart = {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    input?: unknown;
+    output?: string;
+    state?: 'pending' | 'running' | 'done' | 'error';
+};
+export type MindosUiRuntimeStatusPart = {
+    type: 'runtime-status';
+    message: string;
+    runtime?: 'mindos' | 'acp' | 'codex' | 'claude';
+};
+export type MindosUiMessagePart = MindosUiImagePart | MindosUiTextPart | MindosUiReasoningPart | MindosUiToolCallPart | MindosUiRuntimeStatusPart;
+export type MindosUiAskMessage = {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp?: number;
+    skillName?: string;
+    parts?: MindosUiMessagePart[];
+    images?: MindosUiImagePart[];
+};
+export type MindosAgentHistoryMessage = Record<string, unknown>;
+export declare function toMindosAgentMessages(messages: MindosUiAskMessage[]): MindosAgentHistoryMessage[];
+export { detectMindosAgentLoop as detectLoop, isMindosRetryableError as isRetryableError, isMindosTransientError as isTransientError, mindosRetryDelay as retryDelay, sleepMindos as sleep, };
+//# sourceMappingURL=index.d.ts.map