@pasko70/pibo 1.1.0 → 1.2.0

package/dist/core/routed-session.js

@@ -1,7 +1,92 @@
-import { SessionManager } from "@mariozechner/pi-coding-agent";
+import { SessionManager, shouldCompact } from "@mariozechner/pi-coding-agent";
+import { getOpenAiCodexProviderUsageForActiveModel } from "../auth/openai-codex-usage.js";
+import { normalizeSessionErrorDetails, runtimeSessionErrorDetails } from "./session-errors.js";
+import { expandInlineSkills } from "./skill-expansion.js";
+const FAST_SERVICE_TIER = "priority";
+function modelSupportsFastServiceTier(model) {
+    if (!model)
+        return false;
+    if (model.api === "openai-codex-responses")
+        return true;
+    return model.api === "openai-responses" && (model.provider === "openai" || model.provider === "openai-codex");
+}
+function withFastServiceTier(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return payload;
+    return { ...payload, service_tier: FAST_SERVICE_TIER };
+}
+function withFastServiceTierOption(options) {
+    return { ...(options ?? {}), serviceTier: FAST_SERVICE_TIER };
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function parseEmbeddedProviderError(message) {
+    const jsonStart = message.indexOf("{");
+    if (jsonStart === -1)
+        return undefined;
+    try {
+        const parsed = JSON.parse(message.slice(jsonStart));
+        const error = parsed.error;
+        if (!error || typeof error !== "object")
+            return undefined;
+        return {
+            providerType: stringValue(error.type),
+            providerCode: stringValue(error.code),
+            providerParam: stringValue(error.param),
+            providerMessage: stringValue(error.message),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function assistantErrorDetails(message, context) {
+    const rawError = typeof message.errorMessage === "string" ? message.errorMessage : "";
+    const providerError = parseEmbeddedProviderError(rawError);
+    const usage = message.usage && typeof message.usage === "object" ? message.usage : undefined;
+    const contextTokens = numberValue(usage?.totalTokens);
+    const details = normalizeSessionErrorDetails(rawError, {
+        ...(providerError?.providerCode === "context_length_exceeded" ? { category: "context_overflow", errorClass: "provider_context", code: "context_length_exceeded" } : {}),
+        ...providerError,
+        api: stringValue(message.api),
+        provider: stringValue(message.provider),
+        model: stringValue(message.model),
+        contextWindow: context?.contextWindow,
+        contextTokens,
+    });
+    return Object.values(details).some((value) => value !== undefined) ? details : undefined;
+}
+function formatAssistantError(message, context) {
+    const rawError = typeof message.errorMessage === "string" && message.errorMessage.length > 0 ? message.errorMessage : "Assistant message failed.";
+    const details = assistantErrorDetails(message, context);
+    if (details?.category !== "context_overflow")
+        return rawError;
+    const lines = ["Context window exceeded while sending the model request."];
+    if (details.providerMessage)
+        lines.push(`Provider message: ${details.providerMessage}`);
+    if (details.providerCode)
+        lines.push(`Provider code: ${details.providerCode}`);
+    if (details.providerParam)
+        lines.push(`Provider param: ${details.providerParam}`);
+    if (details.api || details.provider || details.model) {
+        lines.push(`Model: ${[details.api, details.provider, details.model].filter(Boolean).join(" / ")}`);
+    }
+    if (details.contextTokens !== undefined || details.contextWindow !== undefined) {
+        const usage = details.contextWindow
+            ? `${details.contextTokens ?? "unknown"} / ${details.contextWindow} tokens`
+            : `${details.contextTokens} tokens`;
+        lines.push(`Context usage: ${usage}`);
+    }
+    lines.push("Automatic overflow compaction will be attempted if auto-compaction is enabled.");
+    return lines.join("\n");
+}
 function messageContentIndex(candidate) {
     return typeof candidate.assistantMessageEvent?.contentIndex === "number"
         ? candidate.assistantMessageEvent.contentIndex
@@ -102,7 +187,7 @@ function normalizeToolExecutionEvent(piboSessionId, candidate) {
     }
     return undefined;
 }
-function normalizePiEvent(piboSessionId, event) {
+function normalizePiEvent(piboSessionId, event, context) {
     if (!event || typeof event !== "object")
         return undefined;
     const candidate = event;
@@ -145,9 +230,8 @@ function normalizePiEvent(piboSessionId, event) {
                 return {
                     type: "session_error",
                     piboSessionId,
-                    error: typeof message.errorMessage === "string" && message.errorMessage.length > 0
-                        ? message.errorMessage
-                        : "Assistant message failed.",
+                    error: formatAssistantError(message, context),
+                    errorDetails: assistantErrorDetails(message, context),
                 };
             }
             const textPart = lastTextPartFromMessage(candidate.message);
@@ -163,49 +247,215 @@ function normalizePiEvent(piboSessionId, event) {
     }
     return undefined;
 }
+function estimateContextTokens(messages) {
+    let chars = 0;
+    for (const msg of messages) {
+        if (!msg || typeof msg !== "object")
+            continue;
+        const message = msg;
+        if (message.role === "user") {
+            const content = message.content;
+            if (typeof content === "string") {
+                chars += content.length;
+            }
+            else if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block && typeof block === "object" && "type" in block && block.type === "text" && "text" in block && typeof block.text === "string") {
+                        chars += block.text.length;
+                    }
+                }
+            }
+        }
+        else if (message.role === "assistant") {
+            const content = message.content;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (!block || typeof block !== "object")
+                        continue;
+                    if ("type" in block) {
+                        if (block.type === "text" && "text" in block && typeof block.text === "string")
+                            chars += block.text.length;
+                        if (block.type === "thinking" && "thinking" in block && typeof block.thinking === "string")
+                            chars += block.thinking.length;
+                        if (block.type === "toolCall" && "name" in block && "arguments" in block) {
+                            chars += String(block.name).length + JSON.stringify(block.arguments).length;
+                        }
+                    }
+                }
+            }
+        }
+        else if (message.role === "toolResult" || message.role === "custom") {
+            const content = message.content;
+            if (typeof content === "string") {
+                chars += content.length;
+            }
+            else if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block && typeof block === "object" && "type" in block && block.type === "text" && "text" in block && typeof block.text === "string") {
+                        chars += block.text.length;
+                    }
+                    if (block && typeof block === "object" && "type" in block && block.type === "image") {
+                        chars += 4800; // approximate image size
+                    }
+                }
+            }
+        }
+    }
+    return Math.ceil(chars / 4);
+}
 export class RoutedSession {
     piboSessionId;
     runtime;
     emit;
     pluginRegistry;
     forwardPiEvents;
+    onPiEventTelemetry;
     onSessionOperation;
+    onKillChildren;
+    onStateChange;
     queue = [];
     processing = false;
     disposed = false;
+    fastMode = false;
+    fastModePatchedAgents = new WeakSet();
     activeMessage;
     activeAssistantIndex;
     nextAssistantIndex = 0;
     activeThinkingIndex;
     nextThinkingIndex = 0;
     unsubscribe;
-    constructor(piboSessionId, runtime, emit, pluginRegistry, forwardPiEvents, onSessionOperation) {
+    isContinuePatched = false;
+    constructor(piboSessionId, runtime, emit, pluginRegistry, forwardPiEvents, onPiEventTelemetry, initialFastMode, onSessionOperation, onKillChildren, onStateChange) {
         this.piboSessionId = piboSessionId;
         this.runtime = runtime;
         this.emit = emit;
         this.pluginRegistry = pluginRegistry;
         this.forwardPiEvents = forwardPiEvents;
+        this.onPiEventTelemetry = onPiEventTelemetry;
         this.onSessionOperation = onSessionOperation;
+        this.onKillChildren = onKillChildren;
+        this.onStateChange = onStateChange;
+        this.fastMode = initialFastMode && this.fastModeSupported();
         this.bindRuntimeSession();
+        this.patchFastModeProviderRequest();
+        this.patchAgentContinue();
         this.runtime.setRebindSession(async () => {
             this.bindRuntimeSession();
+            this.patchFastModeProviderRequest();
+            this.patchAgentContinue();
         });
     }
+    patchFastModeProviderRequest() {
+        const agent = this.runtime.session.agent;
+        if (!agent || typeof agent !== "object")
+            return;
+        if (this.fastModePatchedAgents.has(agent))
+            return;
+        this.fastModePatchedAgents.add(agent);
+        const originalStreamFn = typeof agent.streamFn === "function" ? agent.streamFn.bind(agent) : undefined;
+        if (originalStreamFn) {
+            agent.streamFn = (model, context, options) => {
+                const nextOptions = this.shouldUseFastServiceTier(model) ? withFastServiceTierOption(options) : options;
+                return originalStreamFn(model, context, nextOptions);
+            };
+        }
+        const originalOnPayload = agent.onPayload?.bind(agent);
+        agent.onPayload = async (payload, model) => {
+            const useFastTier = this.shouldUseFastServiceTier(model);
+            const payloadForHooks = useFastTier ? withFastServiceTier(payload) : payload;
+            const nextPayload = originalOnPayload ? await originalOnPayload(payloadForHooks, model) : payloadForHooks;
+            return useFastTier ? withFastServiceTier(nextPayload) : nextPayload;
+        };
+    }
+    shouldUseFastServiceTier(model) {
+        if (this.getFastModeResult().mode !== "fast")
+            return false;
+        return modelSupportsFastServiceTier(model) || modelSupportsFastServiceTier(this.runtime.session.model);
+    }
+    patchAgentContinue() {
+        if (this.isContinuePatched)
+            return;
+        this.isContinuePatched = true;
+        const agent = this.runtime.session.agent;
+        if (!agent)
+            return;
+        const originalContinue = agent.continue.bind(agent);
+        const session = this.runtime.session;
+        agent.continue = async () => {
+            const model = session.model;
+            if (!model)
+                return originalContinue();
+            const contextWindow = model.contextWindow ?? 0;
+            const settings = session.settingsManager.getCompactionSettings();
+            if (!settings.enabled)
+                return originalContinue();
+            let contextTokens = null;
+            const contextUsage = session.getContextUsage();
+            if (contextUsage && contextUsage.tokens !== null) {
+                contextTokens = contextUsage.tokens;
+            }
+            else {
+                // Fallback: estimate tokens from current messages when no post-compaction
+                // assistant usage is available yet. This prevents context overflow between
+                // tool calls after a compaction.
+                contextTokens = estimateContextTokens(session.messages);
+            }
+            if (contextTokens === null)
+                return originalContinue();
+            if (shouldCompact(contextTokens, contextWindow, settings)) {
+                await session.compact();
+            }
+            return originalContinue();
+        };
+    }
     bindRuntimeSession() {
         this.unsubscribe?.();
         this.unsubscribe = this.runtime.session.subscribe((event) => {
-            const normalized = normalizePiEvent(this.piboSessionId, event);
+            this.onPiEventTelemetry?.(this.piboSessionId, event, { status: this.getStatus(), activeEventId: this.activeMessage?.id });
+            const model = this.runtime.session.model;
+            const normalized = normalizePiEvent(this.piboSessionId, event, { contextWindow: numberValue(model?.contextWindow) });
             if (normalized) {
                 this.emit(this.withActiveMessage(normalized));
             }
             if (this.forwardPiEvents) {
                 this.emit({ type: "pi_event", piboSessionId: this.piboSessionId, event });
             }
+            this.handleCompactionEvent(event);
         });
     }
+    handleCompactionEvent(event) {
+        if (!event || typeof event !== "object")
+            return;
+        const candidate = event;
+        if (candidate.type === "compaction_start") {
+            this.emit({
+                type: "compaction_start",
+                piboSessionId: this.piboSessionId,
+                reason: typeof candidate.reason === "string" ? candidate.reason : "unknown",
+            });
+        }
+        if (candidate.type === "compaction_end") {
+            if (candidate.result && candidate.aborted !== true) {
+                // Reset assistant message indices so the next assistant response starts
+                // fresh after compaction, matching the reduced agent context.
+                this.activeAssistantIndex = undefined;
+                this.nextAssistantIndex = 0;
+                this.activeThinkingIndex = undefined;
+                this.nextThinkingIndex = 0;
+            }
+            this.emit({
+                type: "compaction_end",
+                piboSessionId: this.piboSessionId,
+                reason: typeof candidate.reason === "string" ? candidate.reason : "unknown",
+                result: candidate.result,
+                aborted: candidate.aborted === true,
+                errorMessage: typeof candidate.errorMessage === "string" ? candidate.errorMessage : undefined,
+            });
+        }
+    }
     enqueueMessage(event) {
         this.assertActive();
-        this.queue.push(event);
+        this.queue.push({ kind: "message", event });
         const output = {
             type: "message_queued",
             piboSessionId: this.piboSessionId,
@@ -215,11 +465,15 @@ export class RoutedSession {
             source: event.source,
         };
         this.emit(output);
+        this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
         void this.drain();
         return output;
     }
     async executeAction(event) {
         this.assertActive();
+        if (event.action === "compact") {
+            return this.enqueueCompactAction(event);
+        }
         const result = await this.runAction(event);
         if (isSessionOperationResult(result))
             await this.onSessionOperation?.(result, event);
@@ -234,21 +488,42 @@ export class RoutedSession {
         return output;
     }
     getStatus() {
+        const enabledTools = this.runtime.session.getActiveToolNames();
+        const thinkingLevel = this.runtime.session.thinkingLevel;
         return {
             piboSessionId: this.piboSessionId,
             queuedMessages: this.queue.length,
             processing: this.processing,
             streaming: this.runtime.session.isStreaming,
-            activeTools: this.runtime.session.getActiveToolNames(),
+            activeTools: enabledTools,
+            enabledTools,
             cwd: this.runtime.cwd,
             disposed: this.disposed,
+            thinkingLevel,
+            fastMode: this.getFastModeResult().mode === "fast",
         };
     }
+    getContextUsage() {
+        return this.runtime.session.getContextUsage();
+    }
+    getActiveModel() {
+        const model = this.runtime.session.model;
+        return model ? { provider: model.provider, id: model.id } : undefined;
+    }
+    async getProviderUsage() {
+        try {
+            return await getOpenAiCodexProviderUsageForActiveModel(this.getActiveModel());
+        }
+        catch {
+            return undefined;
+        }
+    }
     removeQueuedMessages(predicate) {
         this.assertActive();
         let removed = 0;
         for (let index = this.queue.length - 1; index >= 0; index -= 1) {
-            if (!predicate(this.queue[index]))
+            const item = this.queue[index];
+            if (item.kind !== "message" || !predicate(item.event))
                 continue;
             this.queue.splice(index, 1);
             removed += 1;
@@ -339,6 +614,14 @@ export class RoutedSession {
             cancelled: result.cancelled,
         };
     }
+    async setModel(model) {
+        this.assertActive();
+        const resolved = this.runtime.session.modelRegistry.find(model.provider, model.id);
+        if (!resolved)
+            throw new Error(`Unknown model ${model.provider}/${model.id}`);
+        await this.runtime.session.setModel(resolved);
+        return { provider: resolved.provider, id: resolved.id };
+    }
     setThinkingLevel(level) {
         this.assertActive();
         this.runtime.session.setThinkingLevel(level);
@@ -349,20 +632,44 @@ export class RoutedSession {
         this.runtime.session.cycleThinkingLevel();
         return this.getThinkingResult();
     }
+    getFastMode() {
+        this.assertActive();
+        return this.getFastModeResult();
+    }
+    setFastMode(enabled) {
+        this.assertActive();
+        const before = this.getFastModeResult().mode;
+        if (this.fastModeSupported())
+            this.fastMode = enabled;
+        const current = this.getFastModeResult();
+        return { ...current, changed: before !== current.mode };
+    }
+    async compact(customInstructions) {
+        this.assertActive();
+        return await this.runtime.session.compact(customInstructions);
+    }
     async dispose() {
         if (this.disposed)
             return;
         this.queue.length = 0;
+        this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: true });
         this.unsubscribe?.();
         this.unsubscribe = undefined;
         this.disposed = true;
         await this.runtime.dispose();
     }
+    async kill() {
+        this.queue.length = 0;
+        this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
+        await this.runtime.session.abort();
+        return this.piboSessionId;
+    }
     async cancelMessage(eventId) {
         this.assertActive();
-        const queuedIndex = this.queue.findIndex((event) => event.id === eventId);
+        const queuedIndex = this.queue.findIndex((item) => item.event.id === eventId);
         if (queuedIndex >= 0) {
             this.queue.splice(queuedIndex, 1);
+            this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
             return true;
         }
         if (this.activeMessage?.id === eventId) {
@@ -375,51 +682,101 @@ export class RoutedSession {
         if (this.processing || this.disposed)
             return;
         this.processing = true;
+        this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
         try {
             while (this.queue.length > 0 && !this.disposed) {
-                const event = this.queue.shift();
-                this.emit({
-                    type: "message_started",
-                    piboSessionId: this.piboSessionId,
-                    eventId: event.id,
-                    text: event.text,
-                    source: event.source,
-                });
-                try {
-                    this.activeMessage = event;
-                    this.activeAssistantIndex = undefined;
-                    this.nextAssistantIndex = 0;
-                    this.activeThinkingIndex = undefined;
-                    this.nextThinkingIndex = 0;
-                    await this.runtime.session.prompt(event.text, { source: promptSource(event.source) });
-                    this.emit({
-                        type: "message_finished",
-                        piboSessionId: this.piboSessionId,
-                        eventId: event.id,
-                        source: event.source,
-                    });
+                const item = this.queue.shift();
+                this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
+                if (item.kind === "compact") {
+                    await this.processQueuedCompact(item.event);
                 }
-                catch (error) {
-                    this.emit({
-                        type: "session_error",
-                        piboSessionId: this.piboSessionId,
-                        eventId: event.id,
-                        error: errorMessage(error),
-                    });
-                }
-                finally {
-                    this.activeMessage = undefined;
-                    this.activeAssistantIndex = undefined;
-                    this.nextAssistantIndex = 0;
-                    this.activeThinkingIndex = undefined;
-                    this.nextThinkingIndex = 0;
+                else {
+                    await this.processQueuedMessage(item.event);
                 }
             }
         }
         finally {
             this.processing = false;
+            this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
         }
     }
+    async processQueuedMessage(event) {
+        this.emit({
+            type: "message_started",
+            piboSessionId: this.piboSessionId,
+            eventId: event.id,
+            text: event.text,
+            source: event.source,
+        });
+        try {
+            this.activeMessage = event;
+            this.activeAssistantIndex = undefined;
+            this.nextAssistantIndex = 0;
+            this.activeThinkingIndex = undefined;
+            this.nextThinkingIndex = 0;
+            const expandedText = expandInlineSkills(event.text, this.runtime.session.resourceLoader.getSkills().skills);
+            await this.runtime.session.prompt(expandedText, { source: promptSource(event.source) });
+            this.emit({
+                type: "message_finished",
+                piboSessionId: this.piboSessionId,
+                eventId: event.id,
+                source: event.source,
+            });
+        }
+        catch (error) {
+            const message = errorMessage(error);
+            this.emit({
+                type: "session_error",
+                piboSessionId: this.piboSessionId,
+                eventId: event.id,
+                error: message,
+                errorDetails: runtimeSessionErrorDetails(message),
+            });
+        }
+        finally {
+            this.activeMessage = undefined;
+            this.activeAssistantIndex = undefined;
+            this.nextAssistantIndex = 0;
+            this.activeThinkingIndex = undefined;
+            this.nextThinkingIndex = 0;
+        }
+    }
+    async processQueuedCompact(event) {
+        try {
+            const result = await this.runAction(event);
+            this.emit({
+                type: "execution_result",
+                piboSessionId: this.piboSessionId,
+                eventId: event.id,
+                action: event.action,
+                result,
+            });
+        }
+        catch (error) {
+            const message = errorMessage(error);
+            this.emit({
+                type: "session_error",
+                piboSessionId: this.piboSessionId,
+                eventId: event.id,
+                error: message,
+                errorDetails: runtimeSessionErrorDetails(message),
+            });
+        }
+    }
+    enqueueCompactAction(event) {
+        this.queue.push({ kind: "compact", event });
+        const output = {
+            type: "execution_result",
+            piboSessionId: this.piboSessionId,
+            eventId: event.id,
+            action: event.action,
+            result: { queued: true, queuedMessages: this.queue.length },
+        };
+        this.emit(output);
+        this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
+        void this.drain();
+        return output;
+    }
     async runAction(event) {
         const action = event.action;
         const gatewayAction = this.pluginRegistry.getGatewayAction(action);
@@ -429,6 +786,9 @@ export class RoutedSession {
         return await gatewayAction.execute({
             piboSessionId: this.piboSessionId,
             getStatus: () => this.getStatus(),
+            getContextUsage: () => this.getContextUsage(),
+            getActiveModel: () => this.getActiveModel(),
+            getProviderUsage: () => this.getProviderUsage(),
             clearQueue: () => this.clearQueue(),
             abort: async () => {
                 await this.runtime.session.abort();
@@ -442,8 +802,33 @@ export class RoutedSession {
             getSessionTree: () => this.getSessionTree(),
             navigateSessionTree: (params) => this.navigateSessionTree(params),
             switchSession: (params) => this.switchSession(params),
+            getThinkingLevel: () => this.getThinkingResult(),
             setThinkingLevel: (level) => this.setThinkingLevel(level),
             cycleThinkingLevel: () => this.cycleThinkingLevel(),
+            getFastMode: () => this.getFastMode(),
+            setFastMode: (enabled) => this.setFastMode(enabled),
+            setModel: (model) => this.setModel(model),
+            compact: (customInstructions) => this.compact(customInstructions),
+            kill: async () => {
+                const killed = [await this.kill()];
+                let cancelledRuns = [];
+                if (this.onKillChildren) {
+                    const children = await this.onKillChildren(this.piboSessionId);
+                    killed.push(...children.killed);
+                    cancelledRuns = children.cancelledRuns;
+                }
+                return { killed, cancelledRuns };
+            },
+            killAll: async () => {
+                const killed = [await this.kill()];
+                let cancelledRuns = [];
+                if (this.onKillChildren) {
+                    const children = await this.onKillChildren(this.piboSessionId, { includeRuns: true });
+                    killed.push(...children.killed);
+                    cancelledRuns = children.cancelledRuns;
+                }
+                return { killed, cancelledRuns };
+            },
         }, event);
     }
     assertActive() {
@@ -458,9 +843,17 @@ export class RoutedSession {
             supported: this.runtime.session.supportsThinking(),
         };
     }
+    getFastModeResult() {
+        const supported = this.fastModeSupported();
+        return { mode: supported && this.fastMode ? "fast" : "normal", supported };
+    }
+    fastModeSupported() {
+        return this.runtime.session.supportsThinking() && modelSupportsFastServiceTier(this.runtime.session.model);
+    }
     clearQueue() {
         const cleared = this.queue.length;
         this.queue.length = 0;
+        this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
         return cleared;
     }
     createSessionSnapshot() {
@@ -514,7 +907,8 @@ export class RoutedSession {
                 event.type === "tool_execution_started" ||
                 event.type === "tool_execution_updated" ||
                 event.type === "tool_execution_finished" ||
-                event.type === "session_error")) {
+                event.type === "session_error" ||
+                event.type === "execution_result")) {
             return { ...event, eventId: this.activeMessage.id };
         }
         return event;