@pasko70/pibo 1.1.0 → 1.2.0

package/dist/core/runtime.js

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import { isAbsolute, resolve } from "node:path";
 import { AuthStorage, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createBashToolDefinition, getAgentDir, InteractiveMode, SessionManager, } from "@mariozechner/pi-coding-agent";
 import { DEFAULT_BUILTIN_TOOL_NAMES, } from "./profiles.js";
-import { loadPiboModelDefaults, selectRequestedModelProfile } from "./model-defaults.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";
@@ -16,6 +16,12 @@ import { getActivePiboBasePromptPath } from "./base-prompt.js";
 import { createPiboCompactionPromptExtension } from "./compaction-prompt.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 { 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 resolveProfilePath(cwd, path) {
     return isAbsolute(path) ? path : resolve(cwd, path);
 }
@@ -30,6 +36,24 @@ async function loadContextFiles(cwd, contextFiles) {
     }
     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 = [];
@@ -52,8 +76,13 @@ function getEnabledSkillPaths(cwd, profile) {
         .filter((skill) => skill.enabled !== false)
         .map((skill) => resolveProfilePath(cwd, skill.path));
 }
-function getEnabledToolDefinitions(profile, options, subagentRunner, runToolController) {
-    const profileTools = profile.tools.filter(hasEnabledToolDefinition);
+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
@@ -70,7 +99,8 @@ function getEnabledToolDefinitions(profile, options, subagentRunner, runToolCont
         : [];
     const yieldableTools = [
         ...(runControlBashTool ? [runControlBashTool] : []),
-        ...profileTools.filter((tool) => tool.yieldable !== false).map((tool) => tool.definition),
+        ...profileTools.filter((tool) => tool.yieldable !== false).map((tool) => getToolDefinition(tool, options.toolContext)),
+        ...(runtimeTool && runtimeProfileTool?.yieldable !== false ? [runtimeTool] : []),
         ...subagentTools,
         ...codexCompatTools,
     ];
@@ -79,17 +109,29 @@ function getEnabledToolDefinitions(profile, options, subagentRunner, runToolCont
         : [];
     return [
         ...(runControlBashTool ? [runControlBashTool] : []),
-        ...profileTools.map((tool) => tool.definition),
+        ...profileToolDefinitions,
+        ...(runtimeTool ? [runtimeTool] : []),
         ...subagentTools,
         ...codexCompatTools,
         ...runTools,
     ];
 }
 function hasEnabledToolDefinition(tool) {
-    return tool.enabled !== false && tool.definition !== undefined;
+    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.startsWith("pibo_subagent_") || name.startsWith("pibo_run_");
+    return name === "runtime" || name.startsWith("pibo_subagent_") || name.startsWith("pibo_run_");
 }
 function getBuiltinToolAllowlist(profile, customTools) {
     if (profile.builtinTools === "disabled")
@@ -166,6 +208,7 @@ export async function createPiboRuntime(options = {}) {
     const authStorage = AuthStorage.create();
     const createRuntime = async ({ cwd: runtimeCwd, agentDir: runtimeAgentDir, sessionManager: runtimeSessionManager, sessionStartEvent, }) => {
         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);
@@ -186,6 +229,7 @@ export async function createPiboRuntime(options = {}) {
                 systemPrompt: getActivePiboBasePromptPath(runtimeCwd),
                 agentsFilesOverride: (base) => ({
                     agentsFiles: mergeContextFiles(base.agentsFiles, [
+                        sessionContextFile,
                         ...contextFiles,
                         ...(installedToolContextFile ? [installedToolContextFile] : []),
                         ...(mcpAgentContextFile ? [mcpAgentContextFile] : []),
@@ -193,21 +237,32 @@ export async function createPiboRuntime(options = {}) {
                 }),
             },
         });
+        registerMiniMaxProvider(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(),
-        }, options.subagentRunner, options.runToolController);
+            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),
-            thinkingLevel: options.thinkingLevel,
+            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);
         const resourceLoader = services.resourceLoader;
         const diagnostics = [
             ...piPackageOptions.diagnostics,
@@ -218,6 +273,13 @@ export async function createPiboRuntime(options = {}) {
                 message: `Failed to load extension "${path}": ${error}`,
             })),
         ];
+        if (localRuntimeRegistry) {
+            const originalDispose = created.session.dispose.bind(created.session);
+            created.session.dispose = () => {
+                void localRuntimeRegistry.closeControllerSessions(profile.sessionId ?? "local", { force: true });
+                originalDispose();
+            };
+        }
         return {
             ...created,
             services,
@@ -230,8 +292,34 @@ export async function createPiboRuntime(options = {}) {
         sessionManager,
     });
 }
-function resolveProfileModel(profile, services, cwd) {
-    const requestedModel = selectRequestedModelProfile(profile, loadPiboModelDefaults(cwd));
+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);
@@ -249,7 +337,7 @@ export async function inspectPiboProfile(options = {}) {
     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.yieldable !== false);
+        profile.tools.some((tool) => tool.enabled !== false && (tool.definition !== undefined || tool.createDefinition !== undefined) && tool.yieldable !== false);
     const runtime = await createPiboRuntime({
         cwd,
         profile,
@@ -279,8 +367,8 @@ export async function inspectPiboProfile(options = {}) {
             })),
             tools: profile.tools.map((tool) => ({
                 name: tool.name,
-                hasDefinition: Boolean(tool.definition),
-                registered: registeredToolNames.has(tool.name) || tool.providerTool !== undefined,
+                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) => {

package/dist/core/session-errors.js

@@ -0,0 +1,47 @@
+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: true, userMessage: "The active model request was aborted." };
+    }
+    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 (/\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 };
+}