@pasko70/pibo 3.0.1 → 3.1.0

package/dist/core/output-render-sequence.js

@@ -0,0 +1,331 @@
+import { createHash } from "node:crypto";
+const RENDER_SEQUENCE_SLOTS_PER_MILLISECOND = 1_000;
+const MAX_TRACKED_SESSIONS = 1_024;
+const MAX_RECENT_SEGMENTS_PER_SESSION = 1_024;
+const MAX_RECENT_TOOL_INVOCATIONS_PER_SESSION = 1_024;
+export function outputRenderHighWaterStore(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const candidate = value;
+    return typeof candidate.claimOutputRenderSequence === "function"
+        && typeof candidate.observeOutputRenderSequence === "function"
+        ? candidate
+        : undefined;
+}
+/**
+ * Assigns one monotonic position to each conceptual output segment. Deltas and
+ * lifecycle events for the same segment reuse the first position.
+ */
+export class OutputRenderSequencer {
+    sessions = new Map();
+    now;
+    highWaterStore;
+    constructor(nowOrOptions = Date.now) {
+        if (typeof nowOrOptions === "function") {
+            this.now = nowOrOptions;
+        }
+        else {
+            this.now = nowOrOptions.now ?? Date.now;
+            this.highWaterStore = nowOrOptions.highWaterStore;
+        }
+    }
+    position(event) {
+        const state = this.sessionState(event.piboSessionId);
+        this.trackActiveTurn(state, event);
+        const eventWithToolIdentity = this.positionToolInvocation(state, event);
+        const key = outputRenderSegmentKey(eventWithToolIdentity, state.activeEventId);
+        const supplied = validRenderSequence(eventWithToolIdentity.renderSequence)
+            ? eventWithToolIdentity.renderSequence
+            : undefined;
+        const existing = supplied ?? (key ? state.positions.get(key) : undefined);
+        const renderSequence = existing ?? this.nextSequence(event.piboSessionId, state);
+        state.lastSequence = Math.max(state.lastSequence, renderSequence);
+        if (supplied !== undefined)
+            this.highWaterStore?.observeOutputRenderSequence(event.piboSessionId, supplied);
+        if (key && !state.positions.has(key))
+            state.positions.set(key, renderSequence);
+        const positioned = eventWithToolIdentity.renderSequence === renderSequence
+            ? eventWithToolIdentity
+            : { ...eventWithToolIdentity, renderSequence };
+        if (event.type === "message_finished" || event.type === "session_error") {
+            const eventId = "eventId" in event ? event.eventId : undefined;
+            if ((eventId && state.activeEventId === eventId) || (event.type === "session_error" && !eventId)) {
+                state.activeEventId = undefined;
+            }
+        }
+        const segmentEventId = "eventId" in positioned && positioned.eventId ? positioned.eventId : state.activeEventId;
+        this.updateSegmentLifecycle(state, positioned, key, segmentEventId);
+        this.trimSessions();
+        return positioned;
+    }
+    disposeSession(piboSessionId) {
+        this.sessions.delete(piboSessionId);
+    }
+    disposeAll() {
+        this.sessions.clear();
+    }
+    debugState() {
+        let positionCount = 0;
+        let toolInvocationCount = 0;
+        let completedSessionCount = 0;
+        for (const state of this.sessions.values()) {
+            positionCount += state.positions.size;
+            for (const invocations of state.toolInvocations.values())
+                toolInvocationCount += invocations.length;
+            if (sessionCanBeEvicted(state))
+                completedSessionCount += 1;
+        }
+        return { sessionCount: this.sessions.size, completedSessionCount, sessions: [...this.sessions.keys()], positionCount, toolInvocationCount };
+    }
+    sessionState(piboSessionId) {
+        const existing = this.sessions.get(piboSessionId);
+        if (existing) {
+            this.sessions.delete(piboSessionId);
+            this.sessions.set(piboSessionId, existing);
+            return existing;
+        }
+        const state = {
+            positions: new Map(),
+            segmentEventIds: new Map(),
+            activeSegments: new Set(),
+            completedSegments: new Set(),
+            toolInvocations: new Map(),
+            lastSequence: 0,
+        };
+        this.sessions.set(piboSessionId, state);
+        return state;
+    }
+    positionToolInvocation(state, event) {
+        if (!isToolIdentityEvent(event) || !event.toolCallId)
+            return event;
+        const eventId = event.eventId ?? state.activeEventId;
+        const counterKey = toolInvocationCounterKey(eventId, event.toolCallId);
+        let invocations = state.toolInvocations.get(counterKey);
+        if (!invocations) {
+            invocations = [];
+            state.toolInvocations.set(counterKey, invocations);
+        }
+        let invocation;
+        const transition = eventId ? {
+            piboSessionId: event.piboSessionId,
+            eventId,
+            toolCallId: event.toolCallId,
+            eventType: event.type,
+            ...(event.type === "tool_call" ? { callFingerprint: toolCallFingerprint(event) } : {}),
+        } : undefined;
+        if (validToolInvocationOrdinal(event.toolInvocationOrdinal)) {
+            if (eventId)
+                this.highWaterStore?.observeOutputToolInvocationOrdinal?.(event.piboSessionId, eventId, event.toolCallId, event.toolInvocationOrdinal);
+            if (transition)
+                this.highWaterStore?.observeOutputToolInvocation?.({ ...transition, ordinal: event.toolInvocationOrdinal });
+            invocation = invocations.find((candidate) => candidate.ordinal === event.toolInvocationOrdinal);
+            if (!invocation) {
+                invocation = { ordinal: event.toolInvocationOrdinal, seen: new Set(), closed: false, persistedIdentity: true };
+                invocations.push(invocation);
+            }
+            invocation.persistedIdentity = true;
+        }
+        else {
+            const latest = invocations.at(-1);
+            if (!latest) {
+                invocation = this.createToolInvocation(invocations, event.piboSessionId, eventId, event.toolCallId, transition);
+            }
+            else if (event.type === "tool_call" && (latest.seen.has("tool_call") || (latest.closed && latest.persistedIdentity))) {
+                invocation = this.createToolInvocation(invocations, event.piboSessionId, eventId, event.toolCallId, transition);
+            }
+            else if (event.type === "tool_execution_started" && latest.closed && latest.seen.has("tool_execution_started")) {
+                invocation = this.createToolInvocation(invocations, event.piboSessionId, eventId, event.toolCallId, transition);
+            }
+            else {
+                invocation = latest;
+                if (transition)
+                    this.highWaterStore?.observeOutputToolInvocation?.({ ...transition, ordinal: latest.ordinal });
+            }
+        }
+        invocation.seen.add(event.type);
+        if (event.type === "tool_execution_finished")
+            invocation.closed = true;
+        this.trimToolInvocations(state);
+        const needsEventId = !event.eventId && eventId !== undefined;
+        return event.toolInvocationOrdinal === invocation.ordinal && !needsEventId
+            ? event
+            : { ...event, ...(needsEventId ? { eventId } : {}), toolInvocationOrdinal: invocation.ordinal };
+    }
+    trimToolInvocations(state) {
+        let total = 0;
+        for (const invocations of state.toolInvocations.values())
+            total += invocations.length;
+        while (total > MAX_RECENT_TOOL_INVOCATIONS_PER_SESSION) {
+            let removed = false;
+            for (const [key, invocations] of state.toolInvocations) {
+                const closedIndex = invocations.findIndex((invocation) => invocation.closed);
+                if (closedIndex === -1)
+                    continue;
+                invocations.splice(closedIndex, 1);
+                total -= 1;
+                if (!invocations.length)
+                    state.toolInvocations.delete(key);
+                removed = true;
+                break;
+            }
+            if (!removed)
+                break;
+        }
+    }
+    createToolInvocation(invocations, piboSessionId, eventId, toolCallId, transition) {
+        const localNext = invocations.reduce((maximum, invocation) => Math.max(maximum, invocation.ordinal), -1) + 1;
+        const ordinal = transition
+            ? this.highWaterStore?.claimOrAttachOutputToolInvocation?.(transition)
+                ?? this.highWaterStore?.claimOutputToolInvocationOrdinal?.(piboSessionId, eventId, toolCallId)
+                ?? localNext
+            : localNext;
+        return createInvocation(invocations, ordinal);
+    }
+    updateSegmentLifecycle(state, event, key, segmentEventId) {
+        if (key && !state.segmentEventIds.has(key)) {
+            state.segmentEventIds.set(key, segmentEventId);
+        }
+        if (event.type === "message_finished" || event.type === "session_error") {
+            const boundaryEventId = event.eventId;
+            for (const segmentKey of state.positions.keys()) {
+                if (event.type === "session_error" && !boundaryEventId)
+                    this.completeSegment(state, segmentKey);
+                else if (boundaryEventId && state.segmentEventIds.get(segmentKey) === boundaryEventId)
+                    this.completeSegment(state, segmentKey);
+            }
+            return;
+        }
+        if (!key)
+            return;
+        if (segmentCompletesWith(event))
+            this.completeSegment(state, key);
+        else if (segmentRemainsActive(event)) {
+            state.completedSegments.delete(key);
+            state.activeSegments.add(key);
+        }
+    }
+    completeSegment(state, key) {
+        state.activeSegments.delete(key);
+        state.completedSegments.delete(key);
+        state.completedSegments.add(key);
+        while (state.completedSegments.size > MAX_RECENT_SEGMENTS_PER_SESSION) {
+            const oldest = state.completedSegments.values().next().value;
+            if (oldest === undefined)
+                break;
+            state.completedSegments.delete(oldest);
+            if (!state.activeSegments.has(oldest)) {
+                state.positions.delete(oldest);
+                state.segmentEventIds.delete(oldest);
+            }
+        }
+    }
+    trimSessions() {
+        let removable = [...this.sessions.entries()].filter(([, state]) => sessionCanBeEvicted(state));
+        while (removable.length > MAX_TRACKED_SESSIONS) {
+            const [sessionId] = removable.shift();
+            this.sessions.delete(sessionId);
+        }
+    }
+    trackActiveTurn(state, event) {
+        if (event.type === "message_started" && event.eventId)
+            state.activeEventId = event.eventId;
+    }
+    nextSequence(piboSessionId, state) {
+        const wallClockSequence = Math.floor(this.now()) * RENDER_SEQUENCE_SLOTS_PER_MILLISECOND;
+        const minimum = Math.max(wallClockSequence, state.lastSequence + 1);
+        const next = this.highWaterStore?.claimOutputRenderSequence(piboSessionId, minimum) ?? minimum;
+        state.lastSequence = Math.max(state.lastSequence, next);
+        return next;
+    }
+}
+function createInvocation(invocations, ordinal) {
+    const invocation = { ordinal, seen: new Set(), closed: false, persistedIdentity: false };
+    invocations.push(invocation);
+    return invocation;
+}
+function segmentRemainsActive(event) {
+    return event.type === "message_started"
+        || event.type === "assistant_delta"
+        || event.type === "thinking_started"
+        || event.type === "thinking_delta"
+        || event.type === "tool_call"
+        || event.type === "tool_execution_started"
+        || event.type === "tool_execution_updated";
+}
+function segmentCompletesWith(event) {
+    return event.type === "assistant_message"
+        || event.type === "thinking_finished"
+        || event.type === "tool_execution_finished"
+        || event.type === "execution_result"
+        || event.type === "compaction_end"
+        || event.type === "approval_resolved"
+        || event.type === "user_input_resolved";
+}
+function sessionCanBeEvicted(state) {
+    return state.activeEventId === undefined && state.activeSegments.size === 0;
+}
+export function validToolInvocationOrdinal(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isToolIdentityEvent(event) {
+    return event.type === "tool_call"
+        || event.type === "tool_execution_started"
+        || event.type === "tool_execution_updated"
+        || event.type === "tool_execution_finished"
+        || event.type === "subagent_session";
+}
+function toolInvocationCounterKey(eventId, toolCallId) {
+    return JSON.stringify([eventId ?? "unscoped", toolCallId]);
+}
+function toolCallFingerprint(event) {
+    return createHash("sha256")
+        .update(JSON.stringify([event.toolName, event.argsComplete, event.args]))
+        .digest("hex");
+}
+export function validRenderSequence(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function outputRenderSegmentKey(event, activeEventId) {
+    const eventId = "eventId" in event && event.eventId ? event.eventId : activeEventId;
+    switch (event.type) {
+        case "message_queued":
+        case "message_steered":
+            return eventId ? `user:${eventId}` : undefined;
+        case "message_started":
+        case "message_finished":
+            return eventId ? `turn:${eventId}` : undefined;
+        case "assistant_delta":
+        case "assistant_message":
+            return `assistant:${eventId ?? "active"}:${event.assistantIndex ?? event.contentIndex ?? 0}`;
+        case "thinking_started":
+        case "thinking_delta":
+        case "thinking_finished":
+            return `reasoning:${eventId ?? "active"}:${event.thinkingIndex ?? event.contentIndex ?? 0}`;
+        case "tool_call":
+        case "tool_execution_started":
+        case "tool_execution_updated":
+        case "tool_execution_finished":
+            return `tool:${eventId ?? "active"}:${event.toolCallId}:${event.toolInvocationOrdinal ?? 0}`;
+        case "subagent_session":
+            return event.toolCallId ? `tool:${eventId ?? "active"}:${event.toolCallId}:${event.toolInvocationOrdinal ?? 0}` : undefined;
+        case "compaction_start":
+        case "compaction_end":
+            return `compaction:${eventId ?? "active"}:${event.compactionIndex ?? 0}`;
+        case "approval_requested":
+            return `approval:${eventId ?? "active"}:${event.request.requestId}`;
+        case "approval_resolved":
+            return `approval:${eventId ?? "active"}:${event.requestId}`;
+        case "user_input_requested":
+            return `user-input:${eventId ?? "active"}:${event.request.requestId}`;
+        case "user_input_resolved":
+            return `user-input:${eventId ?? "active"}:${event.requestId}`;
+        case "assistant_usage":
+            return `usage:${eventId ?? "active"}:${event.usageIndex ?? 0}`;
+        case "session_error":
+            return `error:${eventId ?? "active"}`;
+        case "execution_result":
+            return `execution:${eventId ?? event.action}`;
+        default:
+            return undefined;
+    }
+}

package/dist/core/profiles.js

@@ -13,10 +13,14 @@ export function normalizeToolProfile(tool) {
 }
 export const DEFAULT_AGENT_RUNTIME_INSTANCE_ID = "pi";
 export const DEFAULT_BUILTIN_TOOL_NAMES = ["read", "bash", "edit", "write"];
+function cloneModelProfiles(models) {
+    return models.map((model) => ({ ...model }));
+}
 function cloneSubagentProfile(subagent) {
     return {
         ...subagent,
         ...(subagent.model ? { model: { ...subagent.model } } : {}),
+        ...(subagent.modelFallbacks ? { modelFallbacks: cloneModelProfiles(subagent.modelFallbacks) } : {}),
         ...(subagent.runtimeOptions ? { runtimeOptions: structuredClone(subagent.runtimeOptions) } : {}),
     };
 }
@@ -28,6 +32,7 @@ export class InitialSessionContext {
     parentSessionId;
     model;
     mainModel;
+    mainModelFallbacks;
     subagentModel;
     thinkingLevel;
     mainThinkingLevel;
@@ -41,6 +46,7 @@ export class InitialSessionContext {
     mcpServers;
     piPackages;
     contextFiles;
+    diagnostics;
     builtinTools;
     builtinToolNames;
     autoContextFiles;
@@ -54,6 +60,7 @@ export class InitialSessionContext {
         this.parentSessionId = options.parentSessionId;
         this.model = options.model ? { ...options.model } : undefined;
         this.mainModel = options.mainModel ? { ...options.mainModel } : undefined;
+        this.mainModelFallbacks = cloneModelProfiles(options.mainModelFallbacks ?? []);
         this.subagentModel = options.subagentModel ? { ...options.subagentModel } : undefined;
         this.thinkingLevel = options.thinkingLevel;
         this.mainThinkingLevel = options.mainThinkingLevel;
@@ -67,6 +74,7 @@ export class InitialSessionContext {
         this.mcpServers = [...(options.mcpServers ?? [])];
         this.piPackages = [...(options.piPackages ?? [])];
         this.contextFiles = [...(options.contextFiles ?? [])];
+        this.diagnostics = (options.diagnostics ?? []).map((diagnostic) => ({ ...diagnostic }));
         this.builtinTools = options.builtinTools ?? "default";
         this.builtinToolNames = [...(options.builtinToolNames ?? DEFAULT_BUILTIN_TOOL_NAMES)];
         this.autoContextFiles = options.autoContextFiles ?? true;
@@ -82,6 +90,7 @@ export class InitialSessionContextBuilder {
     parentSessionId;
     model;
     mainModel;
+    mainModelFallbacks = [];
     subagentModel;
     thinkingLevel;
     mainThinkingLevel;
@@ -95,6 +104,7 @@ export class InitialSessionContextBuilder {
     mcpServers = [];
     piPackages = [];
     contextFiles = [];
+    diagnostics = [];
     builtinTools = "default";
     builtinToolNames = [...DEFAULT_BUILTIN_TOOL_NAMES];
     autoContextFiles = true;
@@ -124,6 +134,10 @@ export class InitialSessionContextBuilder {
         this.mainModel = { ...model };
         return this;
     }
+    withMainModelFallbacks(models) {
+        this.mainModelFallbacks = cloneModelProfiles(models);
+        return this;
+    }
     withSubagentModel(model) {
         this.subagentModel = { ...model };
         return this;
@@ -220,6 +234,14 @@ export class InitialSessionContextBuilder {
         this.contextFiles.push(...contextFiles);
         return this;
     }
+    addDiagnostic(diagnostic) {
+        this.diagnostics.push({ ...diagnostic });
+        return this;
+    }
+    addDiagnostics(diagnostics) {
+        this.diagnostics.push(...diagnostics.map((diagnostic) => ({ ...diagnostic })));
+        return this;
+    }
     createSession() {
         return new InitialSessionContext({
             profileName: this.profileName,
@@ -229,6 +251,7 @@ export class InitialSessionContextBuilder {
             parentSessionId: this.parentSessionId,
             model: this.model,
             mainModel: this.mainModel,
+            mainModelFallbacks: this.mainModelFallbacks,
             subagentModel: this.subagentModel,
             thinkingLevel: this.thinkingLevel,
             mainThinkingLevel: this.mainThinkingLevel,
@@ -242,6 +265,7 @@ export class InitialSessionContextBuilder {
             mcpServers: this.mcpServers,
             piPackages: this.piPackages,
             contextFiles: this.contextFiles,
+            diagnostics: this.diagnostics,
             builtinTools: this.builtinTools,
             builtinToolNames: this.builtinToolNames,
             autoContextFiles: this.autoContextFiles,

package/dist/core/provider-recovery.js

@@ -1,5 +1,5 @@
 import { isRetryableAssistantError } from "@earendil-works/pi-ai";
-import { classifySessionErrorMessage } from "./session-errors.js";
+import { classifySessionErrorMessage, normalizeSessionErrorDetails } from "./session-errors.js";
 export const PIBO_PROVIDER_RECOVERY_MESSAGE_TYPE = "pibo-provider-recovery-resume";
 export const PIBO_PROVIDER_RECOVERY_PROMPT = "Continue the interrupted task autonomously from the existing session state. The previous provider request failed transiently. Do not wait for more user input, ask the user to repeat the request, or mention this recovery message unless the failure affects the result.";
 const DEFAULT_RECOVERY_BASE_DELAY_MS = 2_000;
@@ -44,6 +44,12 @@ export function isRetryablePiboProviderError(error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     return isRetryablePiboAssistantError({ stopReason: "error", errorMessage });
 }
+export function isPiboProviderFallbackError(message, details) {
+    const normalized = normalizeSessionErrorDetails(message, details);
+    return normalized.origin === "provider"
+        && normalized.category !== "context_overflow"
+        && normalized.category !== "runtime_abort";
+}
 export async function waitForPiboProviderRecovery(attempt, settings, signal) {
     if (signal?.aborted)
         throw new PiboProviderRecoveryCancelledError();

package/dist/core/session-model.js

@@ -1,5 +1,6 @@
-import { selectRequestedModelProfile } from "./model-defaults.js";
+import { selectRequestedModelProfile, sanitizeModelProfile } from "./model-defaults.js";
 import { InitialSessionContext } from "./profiles.js";
+export const PIBO_INITIAL_MODEL_FALLBACKS_METADATA_KEY = "initialModelFallbacks";
 export function resolvePiboSessionActiveModel(input) {
     if (input.piboSession.activeModel)
         return cloneModelProfile(input.piboSession.activeModel);
@@ -8,6 +9,21 @@ export function resolvePiboSessionActiveModel(input) {
         : profileWithSessionIds(input.profile, input.piboSession.piSessionId);
     return selectRequestedModelProfile(sessionProfile, input.modelDefaults ?? {});
 }
+export function resolvePiboSessionModelFallbacks(input) {
+    const persisted = input.piboSession.metadata?.[PIBO_INITIAL_MODEL_FALLBACKS_METADATA_KEY];
+    const configured = persisted !== undefined
+        ? sanitizeModelFallbacks(persisted)
+        : input.parentPiSessionId
+            ? []
+            : sanitizeModelFallbacks(input.profile.mainModelFallbacks);
+    return configured.filter((model) => !sameModel(model, input.activeModel));
+}
+export function withPiboSessionModelFallbacksMetadata(metadata, models) {
+    return {
+        ...(metadata ?? {}),
+        [PIBO_INITIAL_MODEL_FALLBACKS_METADATA_KEY]: sanitizeModelFallbacks(models),
+    };
+}
 function profileWithSessionIds(profile, piSessionId, parentPiSessionId) {
     return new InitialSessionContext({
         profileName: profile.profileName,
@@ -15,6 +31,7 @@ function profileWithSessionIds(profile, piSessionId, parentPiSessionId) {
         parentSessionId: parentPiSessionId,
         model: profile.model,
         mainModel: profile.mainModel,
+        mainModelFallbacks: profile.mainModelFallbacks,
         subagentModel: profile.subagentModel,
         thinkingLevel: profile.thinkingLevel,
         mainThinkingLevel: profile.mainThinkingLevel,
@@ -27,6 +44,7 @@ function profileWithSessionIds(profile, piSessionId, parentPiSessionId) {
         subagents: profile.subagents,
         mcpServers: profile.mcpServers,
         contextFiles: profile.contextFiles,
+        diagnostics: profile.diagnostics,
         piPackages: profile.piPackages,
         builtinTools: profile.builtinTools,
         builtinToolNames: profile.builtinToolNames,
@@ -38,3 +56,21 @@ function profileWithSessionIds(profile, piSessionId, parentPiSessionId) {
 function cloneModelProfile(model) {
     return { provider: model.provider, id: model.id };
 }
+function sanitizeModelFallbacks(value) {
+    if (!Array.isArray(value))
+        return [];
+    const seen = new Set();
+    return value.flatMap((item) => {
+        const model = sanitizeModelProfile(item);
+        if (!model)
+            return [];
+        const key = `${model.provider}\u0000${model.id}`;
+        if (seen.has(key))
+            return [];
+        seen.add(key);
+        return [model];
+    });
+}
+function sameModel(left, right) {
+    return Boolean(right && left.provider === right.provider && left.id === right.id);
+}