@pasko70/pibo 1.9.9 → 1.9.11

package/dist/core/runtime.js

@@ -0,0 +1,529 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,39 @@
+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 };
+}