@pasko70/pibo 1.9.7 → 1.9.9

package/dist/core/runtime.js

@@ -1,529 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { isAbsolute, resolve } from "node:path";
-import { AuthStorage, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createBashToolDefinition, getAgentDir, InteractiveMode, SessionManager, } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_BUILTIN_TOOL_NAMES, InitialSessionContext, } from "./profiles.js";
-import { loadPiboModelDefaults, selectRequestedModelProfile, selectRequestedThinkingLevel } from "./model-defaults.js";
-import { createDefaultPiboProfile } from "../plugins/builtin.js";
-import { createSubagentToolDefinitions, createSubagentToolName, } from "../subagents/tool.js";
-import { createRunToolDefinitions } from "../runs/tools.js";
-import { getInstalledCliToolContextFile } from "../tools/registry.js";
-import { createCodexCompatToolDefinitions } from "../tools/codex-compat.js";
-import { createCodexCompatExtension } from "./codex-compat.js";
-import { createWebSearchProviderExtension, isWebSearchProviderTool } from "../tools/web-search.js";
-import { getMcpAgentContextFile } from "../mcp/agent-context.js";
-import { createPiboSystemPromptTemplateExtension } from "./system-prompt-template.js";
-import { getActivePiboBasePromptPath } from "./base-prompt.js";
-import { createPiboCompactionPromptExtension } from "./compaction-prompt.js";
-import { cancelPiboAssistantContextGuardRecovery, createPiboAssistantContextGuardExtension, createPiboAssistantContextGuardRecovery, isPiboAssistantContextGuardRecoveryPending, registerPiboAssistantContextGuardRecovery, } from "./context-guard.js";
-import { getPiPackageRuntimeOptions } from "../pi-packages/runtime.js";
-import { getDefaultPiboWorkspace } from "./workspace.js";
-import { DEFAULT_USER_TIMEZONE } from "./user-settings.js";
-import { registerMiniMaxProvider } from "../providers/minimax.js";
-import { registerGlmProvider } from "../providers/glm.js";
-import { registerOpenAiGpt56Models } from "../providers/openai-gpt56.js";
-import { PIBO_APP_CONTEXT } from "../app-context.js";
-import { createRuntimeToolDefinition } from "../tools/runtime/tool.js";
-import { RuntimeSessionRegistry } from "../tools/runtime/registry.js";
-import { compactValidationToolResultForContext } from "./test-output-compaction.js";
-function hasOwnRetrySetting(settings, key) {
-    return settings !== undefined && settings !== null && Object.prototype.hasOwnProperty.call(settings, key);
-}
-export function applyPiboRuntimeRetryDefaults(settingsManager, defaults) {
-    if (!defaults)
-        return;
-    const globalRetry = settingsManager.getGlobalSettings().retry;
-    const projectRetry = settingsManager.getProjectSettings().retry;
-    const overrides = {};
-    if (!hasOwnRetrySetting(globalRetry, "enabled") && !hasOwnRetrySetting(projectRetry, "enabled") && defaults.enabled !== undefined) {
-        overrides.enabled = defaults.enabled;
-    }
-    if (!hasOwnRetrySetting(globalRetry, "maxRetries") && !hasOwnRetrySetting(projectRetry, "maxRetries") && defaults.maxRetries !== undefined) {
-        overrides.maxRetries = defaults.maxRetries;
-    }
-    if (!hasOwnRetrySetting(globalRetry, "baseDelayMs") && !hasOwnRetrySetting(projectRetry, "baseDelayMs") && defaults.baseDelayMs !== undefined) {
-        overrides.baseDelayMs = defaults.baseDelayMs;
-    }
-    if (Object.keys(overrides).length > 0)
-        settingsManager.applyOverrides({ retry: overrides });
-}
-function resolveProfilePath(cwd, path) {
-    return isAbsolute(path) ? path : resolve(cwd, path);
-}
-async function loadContextFiles(cwd, contextFiles) {
-    const loaded = [];
-    for (const contextFile of contextFiles) {
-        if (contextFile.enabled === false)
-            continue;
-        const path = resolveProfilePath(cwd, contextFile.path);
-        const content = await readFile(path, "utf-8");
-        loaded.push({ path, content });
-    }
-    return loaded;
-}
-function createSessionContextFile(context) {
-    const piboSessionId = context?.piboSessionId?.trim() || "unknown";
-    const piboRoomId = context?.piboRoomId?.trim() || "unknown";
-    const timezone = context?.timezone?.trim() || DEFAULT_USER_TIMEZONE;
-    return {
-        path: "pibo://runtime/session-context.md",
-        content: [
-            "# Pibo Runtime Context",
-            "",
-            `- App context: ${PIBO_APP_CONTEXT.id}`,
-            `- Pibo Session ID: ${piboSessionId}`,
-            `- Pibo Room ID: ${piboRoomId}`,
-            `- User timezone: ${timezone}`,
-            "",
-            "Login identity gates app access only. Use the Pibo Session ID or Room ID when scheduling jobs, correlating events, or referring to the current session or room.",
-        ].join("\n"),
-    };
-}
-function mergeContextFiles(base, additional) {
-    const seen = new Set();
-    const merged = [];
-    for (const contextFile of [...base, ...additional]) {
-        if (seen.has(contextFile.path))
-            continue;
-        seen.add(contextFile.path);
-        merged.push(contextFile);
-    }
-    return merged;
-}
-function collectResourceDiagnostics(resourceDiagnostics) {
-    return resourceDiagnostics.map((diagnostic) => ({
-        type: diagnostic.type === "collision" ? "warning" : diagnostic.type,
-        message: diagnostic.path ? `${diagnostic.path}: ${diagnostic.message}` : diagnostic.message,
-    }));
-}
-function getEnabledSkillPaths(cwd, profile) {
-    return profile.skills
-        .filter((skill) => skill.enabled !== false)
-        .map((skill) => resolveProfilePath(cwd, skill.path));
-}
-function getEnabledToolDefinitions(profile, options, subagentRunner, runToolController, runtimeToolController) {
-    const runtimeProfileTool = profile.tools.find(isEnabledRuntimeTool);
-    const runtimeTool = runtimeProfileTool && runtimeToolController
-        ? createRuntimeToolDefinition(runtimeToolController)
-        : undefined;
-    const profileTools = profile.tools.filter((tool) => !isRuntimeTool(tool)).filter(hasEnabledToolDefinition);
-    const profileToolDefinitions = profileTools.map((tool) => getToolDefinition(tool, options.toolContext));
-    const codexCompatEnabled = profile.toolPackages.codexCompat === true;
-    const runControlEnabled = profile.toolPackages.runControl === true;
-    const runControlBashTool = runControlEnabled && runToolController
-        ? createBashToolDefinition(options.runtimeCwd, {
-            commandPrefix: options.shellCommandPrefix,
-            shellPath: options.shellPath,
-        })
-        : undefined;
-    const subagentTools = subagentRunner
-        ? createSubagentToolDefinitions(profile.subagents, subagentRunner)
-        : [];
-    const codexCompatTools = codexCompatEnabled
-        ? createCodexCompatToolDefinitions()
-        : [];
-    const yieldableTools = [
-        ...(runControlBashTool ? [runControlBashTool] : []),
-        ...profileTools.filter((tool) => tool.yieldable !== false).map((tool) => getToolDefinition(tool, options.toolContext)),
-        ...(runtimeTool && runtimeProfileTool?.yieldable !== false ? [runtimeTool] : []),
-        ...subagentTools,
-        ...codexCompatTools,
-    ];
-    const runTools = runControlEnabled && runToolController && yieldableTools.length > 0
-        ? createRunToolDefinitions(yieldableTools, runToolController)
-        : [];
-    return [
-        ...(runControlBashTool ? [runControlBashTool] : []),
-        ...profileToolDefinitions,
-        ...(runtimeTool ? [runtimeTool] : []),
-        ...subagentTools,
-        ...codexCompatTools,
-        ...runTools,
-    ];
-}
-function hasEnabledToolDefinition(tool) {
-    return tool.enabled !== false && (tool.definition !== undefined || tool.createDefinition !== undefined);
-}
-function getToolDefinition(tool, context = {}) {
-    if (tool.definition)
-        return tool.definition;
-    return tool.createDefinition(context);
-}
-function isRuntimeTool(tool) {
-    return tool.builtInPiboTool === "runtime" || tool.name === "runtime";
-}
-function isEnabledRuntimeTool(tool) {
-    return tool.enabled !== false && isRuntimeTool(tool);
-}
-function isGeneratedPiboTool(name) {
-    return name === "runtime" || name.startsWith("pibo_subagent_") || name.startsWith("pibo_run_");
-}
-function getBuiltinToolAllowlist(profile, customTools) {
-    if (profile.builtinTools === "disabled")
-        return undefined;
-    const defaultBuiltinTools = new Set(DEFAULT_BUILTIN_TOOL_NAMES);
-    const selectedBuiltinTools = profile.builtinToolNames.filter((name) => defaultBuiltinTools.has(name));
-    if (selectedBuiltinTools.length === DEFAULT_BUILTIN_TOOL_NAMES.length)
-        return undefined;
-    return [...selectedBuiltinTools, ...customTools.map((tool) => tool.name)];
-}
-function getProfileExtensionFactories(profile, extensionFactories, contextGuardRecovery, getSettingsManager) {
-    const piboPromptTemplateExtension = createPiboSystemPromptTemplateExtension();
-    const piboCompactionPromptExtension = createPiboCompactionPromptExtension({ getSettingsManager });
-    const piboContextGuardExtension = createPiboAssistantContextGuardExtension({}, contextGuardRecovery);
-    const providerToolExtensions = profile.tools
-        .filter((tool) => tool.enabled !== false)
-        .filter(isWebSearchProviderTool)
-        .map((tool) => createWebSearchProviderExtension(tool.providerTool));
-    if (profile.toolPackages.codexCompat !== true) {
-        return [
-            piboPromptTemplateExtension,
-            piboCompactionPromptExtension,
-            piboContextGuardExtension,
-            ...providerToolExtensions,
-            ...(extensionFactories ?? []),
-        ];
-    }
-    return [
-        piboPromptTemplateExtension,
-        piboCompactionPromptExtension,
-        piboContextGuardExtension,
-        createCodexCompatExtension({
-            isChildSession: profile.parentSessionId !== undefined,
-        }),
-        ...providerToolExtensions,
-        ...(extensionFactories ?? []),
-    ];
-}
-function createInspectionSubagentRunner() {
-    return {
-        async runSubagent() {
-            throw new Error("Profile inspection cannot execute subagents");
-        },
-    };
-}
-function createInspectionRunToolController() {
-    const fail = () => {
-        throw new Error("Profile inspection cannot execute run-control tools");
-    };
-    return {
-        startToolRun: fail,
-        listRuns: () => [],
-        getRunStatus: fail,
-        waitForRun: fail,
-        readRun: fail,
-        cancelRun: fail,
-        ackRun: fail,
-    };
-}
-async function createSessionManager(cwd, profile, persistSession) {
-    if (persistSession && profile.sessionId) {
-        const existing = (await SessionManager.list(cwd)).find((session) => session.id === profile.sessionId);
-        if (existing)
-            return SessionManager.open(existing.path, undefined, cwd);
-    }
-    const sessionManager = persistSession ? SessionManager.create(cwd) : SessionManager.inMemory(cwd);
-    if (profile.sessionId) {
-        sessionManager.newSession({ id: profile.sessionId, parentSession: profile.parentSessionId });
-    }
-    return sessionManager;
-}
-export async function createPiboRuntime(options = {}) {
-    const cwd = options.cwd ?? getDefaultPiboWorkspace();
-    const profile = options.profile ?? createDefaultPiboProfile();
-    const agentDir = getAgentDir();
-    const sessionManager = await createSessionManager(cwd, profile, options.persistSession !== false);
-    const authStorage = AuthStorage.create();
-    const createRuntime = async ({ cwd: runtimeCwd, agentDir: runtimeAgentDir, sessionManager: runtimeSessionManager, sessionStartEvent, }) => {
-        const contextGuardRecovery = createPiboAssistantContextGuardRecovery();
-        const contextFiles = await loadContextFiles(runtimeCwd, profile.contextFiles);
-        const sessionContextFile = createSessionContextFile({ piboSessionId: profile.sessionId, ...options.sessionContext });
-        const installedToolContextFile = getInstalledCliToolContextFile();
-        const mcpAgentContextFile = await getMcpAgentContextFile(profile.mcpServers);
-        const skillPaths = getEnabledSkillPaths(runtimeCwd, profile);
-        const piPackageOptions = getPiPackageRuntimeOptions(runtimeCwd, profile);
-        let runtimeSettingsManager;
-        const services = await createAgentSessionServices({
-            cwd: runtimeCwd,
-            agentDir: runtimeAgentDir,
-            authStorage,
-            resourceLoaderOptions: {
-                ...piPackageOptions.resourceLoaderOptions,
-                additionalSkillPaths: skillPaths,
-                extensionFactories: getProfileExtensionFactories(profile, options.extensionFactories, contextGuardRecovery, () => runtimeSettingsManager),
-                noExtensions: true,
-                noSkills: true,
-                noPromptTemplates: true,
-                noThemes: true,
-                noContextFiles: profile.autoContextFiles === false,
-                systemPrompt: getActivePiboBasePromptPath(runtimeCwd),
-                agentsFilesOverride: (base) => ({
-                    agentsFiles: mergeContextFiles(base.agentsFiles, [
-                        sessionContextFile,
-                        ...contextFiles,
-                        ...(installedToolContextFile ? [installedToolContextFile] : []),
-                        ...(mcpAgentContextFile ? [mcpAgentContextFile] : []),
-                    ]),
-                }),
-            },
-        });
-        runtimeSettingsManager = services.settingsManager;
-        applyPiboRuntimeRetryDefaults(services.settingsManager, options.retryDefaults);
-        registerOpenAiGpt56Models(services.modelRegistry);
-        registerMiniMaxProvider(services.modelRegistry);
-        registerGlmProvider(services.modelRegistry);
-        const ownsLocalRuntimeRegistry = options.runtimeToolController === undefined && profile.tools.some(isEnabledRuntimeTool);
-        const localRuntimeRegistry = ownsLocalRuntimeRegistry ? new RuntimeSessionRegistry({ cwd: runtimeCwd }) : undefined;
-        const runtimeToolController = options.runtimeToolController
-            ?? localRuntimeRegistry?.createController(profile.sessionId ?? "local");
-        const customTools = getEnabledToolDefinitions(profile, {
-            runtimeCwd,
-            shellCommandPrefix: services.settingsManager.getShellCommandPrefix(),
-            shellPath: services.settingsManager.getShellPath(),
-            toolContext: {
-                piboSessionId: options.sessionContext?.piboSessionId ?? profile.sessionId,
-                piboRoomId: options.sessionContext?.piboRoomId,
-            },
-        }, options.subagentRunner, options.runToolController, runtimeToolController);
-        const modelDefaults = options.modelDefaults ?? loadPiboModelDefaults(runtimeCwd);
-        const created = await createAgentSessionFromServices({
-            services,
-            sessionManager: runtimeSessionManager,
-            sessionStartEvent,
-            model: resolveProfileModel(profile, services, runtimeCwd, modelDefaults, options.activeModel),
-            thinkingLevel: options.thinkingLevel ?? selectRequestedThinkingLevel(profile, modelDefaults),
-            customTools,
-            noTools: profile.builtinTools === "disabled" ? "builtin" : undefined,
-            tools: getBuiltinToolAllowlist(profile, customTools),
-        });
-        installValidationOutputCompaction(created.session.agent);
-        registerPiboAssistantContextGuardRecovery(created.session, contextGuardRecovery);
-        if (options.contextGuardTuiQueueOrdering === true) {
-            installPiboContextGuardTuiQueueOrdering(created.session);
-        }
-        const resourceLoader = services.resourceLoader;
-        const diagnostics = [
-            ...piPackageOptions.diagnostics,
-            ...services.diagnostics,
-            ...collectResourceDiagnostics(resourceLoader.getSkills().diagnostics),
-            ...resourceLoader.getExtensions().errors.map(({ path, error }) => ({
-                type: "error",
-                message: `Failed to load extension "${path}": ${error}`,
-            })),
-        ];
-        const originalDispose = created.session.dispose.bind(created.session);
-        created.session.dispose = () => {
-            cancelPiboAssistantContextGuardRecovery(created.session, new Error("Context guard recovery cancelled because the Pi session was disposed"));
-            if (localRuntimeRegistry) {
-                void localRuntimeRegistry.closeControllerSessions(profile.sessionId ?? "local", { force: true });
-            }
-            originalDispose();
-        };
-        return {
-            ...created,
-            services,
-            diagnostics,
-        };
-    };
-    return createAgentSessionRuntime(createRuntime, {
-        cwd,
-        agentDir,
-        sessionManager,
-    });
-}
-function installValidationOutputCompaction(agent) {
-    const target = agent;
-    if (!target)
-        return;
-    const previous = target.afterToolCall;
-    target.afterToolCall = async (context, signal) => {
-        const prior = await previous?.(context, signal);
-        const mergedContext = mergePriorAfterToolCallResult(context, prior);
-        return compactValidationToolResultForContext(mergedContext) ?? prior;
-    };
-}
-function mergePriorAfterToolCallResult(context, prior) {
-    if (!prior || typeof prior !== "object" || Array.isArray(prior))
-        return context;
-    const replacement = prior;
-    return {
-        ...context,
-        isError: typeof replacement.isError === "boolean" ? replacement.isError : context.isError,
-        result: {
-            ...context.result,
-            content: Array.isArray(replacement.content) ? replacement.content : context.result.content,
-            details: replacement.details !== undefined ? replacement.details : context.result.details,
-            terminate: typeof replacement.terminate === "boolean" ? replacement.terminate : context.result.terminate,
-        },
-    };
-}
-function resolveProfileModel(profile, services, cwd, modelDefaults, activeModel) {
-    const requestedModel = activeModel ? { ...activeModel } : selectRequestedModelProfile(profile, modelDefaults ?? loadPiboModelDefaults(cwd));
-    if (!requestedModel)
-        return undefined;
-    const model = services.modelRegistry.find(requestedModel.provider, requestedModel.id);
-    if (!model) {
-        throw new Error(`Profile "${profile.profileName}" requests unknown model ${requestedModel.provider}/${requestedModel.id}.`);
-    }
-    if (!services.modelRegistry.hasConfiguredAuth(model)) {
-        throw new Error(`Profile "${profile.profileName}" requires configured auth for ${requestedModel.provider}/${requestedModel.id}.`);
-    }
-    return model;
-}
-export async function inspectPiboProfile(options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const profile = options.profile ?? createDefaultPiboProfile();
-    const runtimeProfile = new InitialSessionContext({
-        profileName: profile.profileName,
-        sessionId: profile.sessionId,
-        parentSessionId: profile.parentSessionId,
-        skills: profile.skills,
-        tools: profile.tools,
-        subagents: profile.subagents,
-        mcpServers: profile.mcpServers,
-        piPackages: profile.piPackages,
-        contextFiles: profile.contextFiles,
-        builtinTools: profile.builtinTools,
-        builtinToolNames: profile.builtinToolNames,
-        autoContextFiles: profile.autoContextFiles,
-        toolPackages: profile.toolPackages,
-    });
-    const hasEnabledSubagents = profile.subagents.some((subagent) => subagent.enabled !== false);
-    const hasYieldableTools = profile.toolPackages.runControl === true ||
-        hasEnabledSubagents ||
-        profile.tools.some((tool) => tool.enabled !== false && (tool.definition !== undefined || tool.createDefinition !== undefined) && tool.yieldable !== false);
-    const runtime = await createPiboRuntime({
-        cwd,
-        ...options,
-        profile: runtimeProfile,
-        persistSession: false,
-        modelDefaults: {},
-        activeModel: undefined,
-        subagentRunner: options.subagentRunner ?? (hasEnabledSubagents ? createInspectionSubagentRunner() : undefined),
-        runToolController: options.runToolController ?? (hasYieldableTools ? createInspectionRunToolController() : undefined),
-    });
-    try {
-        const resourceLoader = runtime.services.resourceLoader;
-        const activeToolNames = new Set(runtime.session.getActiveToolNames());
-        const registeredToolNames = new Set(runtime.session.getAllTools().map((tool) => tool.name));
-        const profileToolNames = new Set(profile.tools.map((tool) => tool.name));
-        const generatedTools = runtime.session
-            .getAllTools()
-            .filter((tool) => isGeneratedPiboTool(tool.name) && !profileToolNames.has(tool.name))
-            .map((tool) => ({
-            name: tool.name,
-            hasDefinition: true,
-            registered: true,
-            active: activeToolNames.has(tool.name),
-        }));
-        return {
-            profileName: profile.profileName,
-            ...(profile.model ? { model: { ...profile.model } } : {}),
-            ...(profile.mainModel ? { mainModel: { ...profile.mainModel } } : {}),
-            ...(profile.subagentModel ? { subagentModel: { ...profile.subagentModel } } : {}),
-            ...(profile.thinkingLevel ? { thinkingLevel: profile.thinkingLevel } : {}),
-            ...(profile.mainThinkingLevel ? { mainThinkingLevel: profile.mainThinkingLevel } : {}),
-            ...(profile.subagentThinkingLevel ? { subagentThinkingLevel: profile.subagentThinkingLevel } : {}),
-            ...(profile.fast !== undefined ? { fast: profile.fast } : {}),
-            ...(profile.mainFast !== undefined ? { mainFast: profile.mainFast } : {}),
-            ...(profile.subagentFast !== undefined ? { subagentFast: profile.subagentFast } : {}),
-            builtinTools: profile.builtinTools,
-            builtinToolNames: [...profile.builtinToolNames],
-            autoContextFiles: profile.autoContextFiles,
-            toolPackages: { ...profile.toolPackages },
-            skills: resourceLoader.getSkills().skills.map((skill) => ({
-                name: skill.name,
-                path: skill.filePath,
-            })),
-            tools: profile.tools.map((tool) => ({
-                name: tool.name,
-                hasDefinition: Boolean(tool.definition) || Boolean(tool.createDefinition) || isRuntimeTool(tool),
-                registered: registeredToolNames.has(tool.name) || tool.providerTool !== undefined || isRuntimeTool(tool),
-                active: activeToolNames.has(tool.name) || tool.providerTool !== undefined,
-            })).concat(generatedTools),
-            subagents: profile.subagents.map((subagent) => {
-                const toolName = createSubagentToolName(subagent.name);
-                return {
-                    name: subagent.name,
-                    targetProfile: subagent.targetProfile,
-                    active: activeToolNames.has(toolName),
-                };
-            }),
-            mcpServers: [...profile.mcpServers],
-            piPackages: profile.piPackages.map((pkg) => ({
-                id: pkg.id,
-                active: pkg.enabled !== false,
-            })),
-            contextFiles: resourceLoader.getAgentsFiles().agentsFiles.map((contextFile) => ({
-                path: contextFile.path,
-                bytes: Buffer.byteLength(contextFile.content, "utf-8"),
-            })),
-            diagnostics: [...runtime.diagnostics],
-        };
-    }
-    finally {
-        await runtime.dispose();
-    }
-}
-function installPiboContextGuardTuiQueueOrdering(session) {
-    const originalSubscribe = session.subscribe.bind(session);
-    const originalPrompt = session.prompt.bind(session);
-    const originalSteer = session.steer.bind(session);
-    session.subscribe = ((listener) => originalSubscribe((event) => {
-        if (event.type === "compaction_end"
-            && event.result
-            && isPiboAssistantContextGuardRecoveryPending(session)) {
-            listener({ ...event, willRetry: true });
-            return;
-        }
-        listener(event);
-    }));
-    session.prompt = async (text, options) => {
-        if (isPiboAssistantContextGuardRecoveryPending(session)) {
-            if (!session.isStreaming) {
-                await session.followUp(text, options?.images);
-                options?.preflightResult?.(true);
-                return;
-            }
-            await originalPrompt(text, { ...options, streamingBehavior: "followUp" });
-            return;
-        }
-        await originalPrompt(text, options);
-    };
-    session.steer = async (text, images) => {
-        if (isPiboAssistantContextGuardRecoveryPending(session)) {
-            await session.followUp(text, images);
-            return;
-        }
-        await originalSteer(text, images);
-    };
-}
-export async function runPiboTui(options = {}) {
-    const profile = options.profile ?? createDefaultPiboProfile();
-    const hasEnabledSubagents = profile.subagents.some((subagent) => subagent.enabled !== false);
-    if (hasEnabledSubagents && (!options.subagentRunner || !options.runToolController)) {
-        console.error(`Error: Profile "${profile.profileName}" uses subagents and requires the routed pibo runtime. ` +
-            `Use "npm run tui:routed -- ${profile.profileName}" for local TUI QA.`);
-        process.exitCode = 1;
-        return;
-    }
-    const runtime = await createPiboRuntime({ ...options, profile, contextGuardTuiQueueOrdering: true });
-    try {
-        const fatal = runtime.diagnostics.find((diagnostic) => diagnostic.type === "error");
-        for (const diagnostic of runtime.diagnostics) {
-            const prefix = diagnostic.type === "warning" ? "Warning" : diagnostic.type === "error" ? "Error" : "Info";
-            console.error(`${prefix}: ${diagnostic.message}`);
-        }
-        if (fatal) {
-            process.exitCode = 1;
-            return;
-        }
-        const interactiveMode = new InteractiveMode(runtime, {
-            verbose: true,
-            modelFallbackMessage: runtime.modelFallbackMessage,
-        });
-        await interactiveMode.run();
-    }
-    finally {
-        await runtime.dispose();
-    }
-}

package/dist/core/session-errors.js

@@ -1,76 +0,0 @@
-const PROVIDER_NETWORK_ERROR_MARKERS = [
-    "fetch failed",
-    "network error",
-    "connection error",
-    "connection refused",
-    "connection lost",
-    "connection reset",
-    "other side closed",
-    "upstream connect",
-    "reset before headers",
-    "socket hang up",
-    "socket connection was closed",
-    "eai_again",
-    "enotfound",
-    "econnreset",
-    "econnrefused",
-    "etimedout",
-];
-export function classifySessionErrorMessage(message, options = {}) {
-    const normalized = message.toLowerCase();
-    if (normalized.includes("context_length_exceeded") || normalized.includes("context window")) {
-        return { category: "context_overflow", errorClass: "provider_context", code: "context_length_exceeded", origin: "provider", retryable: false, userMessage: "The model context window was exceeded." };
-    }
-    if (normalized.includes("websocket")) {
-        return { category: "provider_transport", errorClass: "provider_transport", code: "websocket_error", origin: "provider", retryable: true, userMessage: "The provider WebSocket connection failed." };
-    }
-    if (normalized.includes("request was aborted") || normalized.includes("aborted")) {
-        return { category: "runtime_abort", errorClass: "runtime_abort", code: "request_aborted", origin: "runtime", retryable: false, userMessage: "The active model request was aborted." };
-    }
-    if (normalized.includes("insufficient_quota")
-        || normalized.includes("quota exceeded")
-        || normalized.includes("out of budget")
-        || normalized.includes("billing")
-        || normalized.includes("usage limit")
-        || normalized.includes("available balance")) {
-        return { category: "quota_exhausted", errorClass: "provider_rate_limit", code: "quota_exhausted", origin: "provider", retryable: false, userMessage: "The provider quota or billing limit was reached." };
-    }
-    if (normalized.includes("rate limit") || normalized.includes("429")) {
-        return { category: "rate_limit", errorClass: "provider_rate_limit", code: "rate_limited", origin: "provider", retryable: true, userMessage: "The provider rate limit was reached." };
-    }
-    if (normalized.includes("unauthorized") || normalized.includes("forbidden") || normalized.includes("api key") || normalized.includes("401") || normalized.includes("403")) {
-        return { category: "auth", errorClass: "provider_auth", code: "provider_auth_failed", origin: "provider", retryable: false, userMessage: "Provider authentication failed." };
-    }
-    if (normalized.includes("timeout") || normalized.includes("timed out")) {
-        return { category: "provider_transport", errorClass: "provider_transport", code: "timeout", origin: "provider", retryable: true, userMessage: "The provider request timed out." };
-    }
-    if (PROVIDER_NETWORK_ERROR_MARKERS.some((marker) => normalized.includes(marker))) {
-        return { category: "provider_transport", errorClass: "provider_transport", code: "network_error", origin: "provider", retryable: true, userMessage: "The provider network connection failed." };
-    }
-    if (/\b5\d\d\b/.test(normalized)) {
-        return { category: "provider_server", errorClass: "provider_server", code: "provider_server_error", origin: "provider", retryable: true, userMessage: "The provider returned a server error." };
-    }
-    if (options.hasProviderContext) {
-        return { category: "provider_error", errorClass: "provider_error", code: "provider_error", origin: "provider", retryable: undefined, userMessage: "The provider request failed." };
-    }
-    return { category: "runtime_error", errorClass: "runtime_error", code: "runtime_error", origin: "runtime", retryable: undefined, userMessage: "The session runtime failed." };
-}
-export function normalizeSessionErrorDetails(message, details) {
-    const classification = classifySessionErrorMessage(details?.providerCode ?? details?.providerMessage ?? message, {
-        hasProviderContext: Boolean(details?.api || details?.provider || details?.model || details?.providerCode || details?.providerMessage),
-    });
-    return {
-        ...classification,
-        ...details,
-        category: details?.category ?? classification.category,
-        errorClass: details?.errorClass ?? classification.errorClass,
-        code: details?.code ?? details?.providerCode ?? classification.code,
-        origin: details?.origin ?? classification.origin,
-        retryable: details?.retryable ?? classification.retryable,
-        userMessage: details?.userMessage ?? classification.userMessage,
-        severity: details?.severity ?? "error",
-    };
-}
-export function runtimeSessionErrorDetails(message) {
-    return normalizeSessionErrorDetails(message, undefined);
-}

package/dist/core/session-model.js

@@ -1,39 +0,0 @@
-import { selectRequestedModelProfile } from "./model-defaults.js";
-import { InitialSessionContext } from "./profiles.js";
-export function resolvePiboSessionActiveModel(input) {
-    if (input.piboSession.activeModel)
-        return cloneModelProfile(input.piboSession.activeModel);
-    const sessionProfile = input.parentPiSessionId
-        ? profileWithSessionIds(input.profile, input.piboSession.piSessionId, input.parentPiSessionId)
-        : profileWithSessionIds(input.profile, input.piboSession.piSessionId);
-    return selectRequestedModelProfile(sessionProfile, input.modelDefaults ?? {});
-}
-function profileWithSessionIds(profile, piSessionId, parentPiSessionId) {
-    return new InitialSessionContext({
-        profileName: profile.profileName,
-        sessionId: piSessionId,
-        parentSessionId: parentPiSessionId,
-        model: profile.model,
-        mainModel: profile.mainModel,
-        subagentModel: profile.subagentModel,
-        thinkingLevel: profile.thinkingLevel,
-        mainThinkingLevel: profile.mainThinkingLevel,
-        subagentThinkingLevel: profile.subagentThinkingLevel,
-        fast: profile.fast,
-        mainFast: profile.mainFast,
-        subagentFast: profile.subagentFast,
-        skills: profile.skills,
-        tools: profile.tools,
-        subagents: profile.subagents,
-        mcpServers: profile.mcpServers,
-        contextFiles: profile.contextFiles,
-        piPackages: profile.piPackages,
-        builtinTools: profile.builtinTools,
-        builtinToolNames: profile.builtinToolNames,
-        autoContextFiles: profile.autoContextFiles,
-        toolPackages: profile.toolPackages,
-    });
-}
-function cloneModelProfile(model) {
-    return { provider: model.provider, id: model.id };
-}