@pasko70/pibo 1.9.9 → 1.9.11

package/dist/core/profiles.js

@@ -0,0 +1,210 @@
+export const DEFAULT_BUILTIN_TOOL_NAMES = ["read", "bash", "edit", "write"];
+export class InitialSessionContext {
+    profileName;
+    sessionId;
+    parentSessionId;
+    model;
+    mainModel;
+    subagentModel;
+    thinkingLevel;
+    mainThinkingLevel;
+    subagentThinkingLevel;
+    fast;
+    mainFast;
+    subagentFast;
+    skills;
+    tools;
+    subagents;
+    mcpServers;
+    piPackages;
+    contextFiles;
+    builtinTools;
+    builtinToolNames;
+    autoContextFiles;
+    toolPackages;
+    constructor(options) {
+        this.profileName = options.profileName;
+        this.sessionId = options.sessionId;
+        this.parentSessionId = options.parentSessionId;
+        this.model = options.model ? { ...options.model } : undefined;
+        this.mainModel = options.mainModel ? { ...options.mainModel } : undefined;
+        this.subagentModel = options.subagentModel ? { ...options.subagentModel } : undefined;
+        this.thinkingLevel = options.thinkingLevel;
+        this.mainThinkingLevel = options.mainThinkingLevel;
+        this.subagentThinkingLevel = options.subagentThinkingLevel;
+        this.fast = options.fast;
+        this.mainFast = options.mainFast;
+        this.subagentFast = options.subagentFast;
+        this.skills = [...(options.skills ?? [])];
+        this.tools = [...(options.tools ?? [])];
+        this.subagents = [...(options.subagents ?? [])];
+        this.mcpServers = [...(options.mcpServers ?? [])];
+        this.piPackages = [...(options.piPackages ?? [])];
+        this.contextFiles = [...(options.contextFiles ?? [])];
+        this.builtinTools = options.builtinTools ?? "default";
+        this.builtinToolNames = [...(options.builtinToolNames ?? DEFAULT_BUILTIN_TOOL_NAMES)];
+        this.autoContextFiles = options.autoContextFiles ?? true;
+        this.toolPackages = { ...(options.toolPackages ?? {}) };
+    }
+}
+export class InitialSessionContextBuilder {
+    profileName;
+    sessionId;
+    parentSessionId;
+    model;
+    mainModel;
+    subagentModel;
+    thinkingLevel;
+    mainThinkingLevel;
+    subagentThinkingLevel;
+    fast;
+    mainFast;
+    subagentFast;
+    skills = [];
+    tools = [];
+    subagents = [];
+    mcpServers = [];
+    piPackages = [];
+    contextFiles = [];
+    builtinTools = "default";
+    builtinToolNames = [...DEFAULT_BUILTIN_TOOL_NAMES];
+    autoContextFiles = true;
+    toolPackages = {};
+    constructor(profileName) {
+        this.profileName = profileName;
+    }
+    withSessionId(sessionId) {
+        this.sessionId = sessionId;
+        return this;
+    }
+    withParentSessionId(parentSessionId) {
+        this.parentSessionId = parentSessionId;
+        return this;
+    }
+    withModel(model) {
+        this.model = { ...model };
+        return this;
+    }
+    withMainModel(model) {
+        this.mainModel = { ...model };
+        return this;
+    }
+    withSubagentModel(model) {
+        this.subagentModel = { ...model };
+        return this;
+    }
+    withThinkingLevel(level) {
+        this.thinkingLevel = level;
+        return this;
+    }
+    withMainThinkingLevel(level) {
+        this.mainThinkingLevel = level;
+        return this;
+    }
+    withSubagentThinkingLevel(level) {
+        this.subagentThinkingLevel = level;
+        return this;
+    }
+    withFastMode(enabled) {
+        this.fast = enabled;
+        return this;
+    }
+    withMainFastMode(enabled) {
+        this.mainFast = enabled;
+        return this;
+    }
+    withSubagentFastMode(enabled) {
+        this.subagentFast = enabled;
+        return this;
+    }
+    withBuiltinTools(mode) {
+        this.builtinTools = mode;
+        return this;
+    }
+    withBuiltinToolNames(names) {
+        this.builtinToolNames = [...names];
+        return this;
+    }
+    withAutoContextFiles(enabled) {
+        this.autoContextFiles = enabled;
+        return this;
+    }
+    withToolPackages(packages) {
+        this.toolPackages = { ...packages };
+        return this;
+    }
+    addSkill(skill) {
+        this.skills.push(skill);
+        return this;
+    }
+    addSkills(skills) {
+        this.skills.push(...skills);
+        return this;
+    }
+    addTool(tool) {
+        this.tools.push(tool);
+        return this;
+    }
+    addTools(tools) {
+        this.tools.push(...tools);
+        return this;
+    }
+    addSubagent(subagent) {
+        this.subagents.push(subagent);
+        return this;
+    }
+    addSubagents(subagents) {
+        this.subagents.push(...subagents);
+        return this;
+    }
+    withMcpServers(mcpServers) {
+        this.mcpServers = [...mcpServers];
+        return this;
+    }
+    withPiPackages(packages) {
+        this.piPackages = [...packages];
+        return this;
+    }
+    addPiPackage(pkg) {
+        this.piPackages.push(pkg);
+        return this;
+    }
+    addPiPackages(packages) {
+        this.piPackages.push(...packages);
+        return this;
+    }
+    addContextFile(contextFile) {
+        this.contextFiles.push(contextFile);
+        return this;
+    }
+    addContextFiles(contextFiles) {
+        this.contextFiles.push(...contextFiles);
+        return this;
+    }
+    createSession() {
+        return new InitialSessionContext({
+            profileName: this.profileName,
+            sessionId: this.sessionId,
+            parentSessionId: this.parentSessionId,
+            model: this.model,
+            mainModel: this.mainModel,
+            subagentModel: this.subagentModel,
+            thinkingLevel: this.thinkingLevel,
+            mainThinkingLevel: this.mainThinkingLevel,
+            subagentThinkingLevel: this.subagentThinkingLevel,
+            fast: this.fast,
+            mainFast: this.mainFast,
+            subagentFast: this.subagentFast,
+            skills: this.skills,
+            tools: this.tools,
+            subagents: this.subagents,
+            mcpServers: this.mcpServers,
+            piPackages: this.piPackages,
+            contextFiles: this.contextFiles,
+            builtinTools: this.builtinTools,
+            builtinToolNames: this.builtinToolNames,
+            autoContextFiles: this.autoContextFiles,
+            toolPackages: this.toolPackages,
+        });
+    }
+}

package/dist/core/provider-recovery.js

@@ -0,0 +1,64 @@
+import { isRetryableAssistantError } from "@earendil-works/pi-ai";
+import { classifySessionErrorMessage } 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;
+const DEFAULT_RECOVERY_MAX_DELAY_MS = 60_000;
+export class PiboProviderRecoveryCancelledError extends Error {
+    constructor(message = "Provider recovery cancelled") {
+        super(message);
+        this.name = "PiboProviderRecoveryCancelledError";
+    }
+}
+export function resolvePiboProviderRecoverySettings(settingsManager) {
+    if (!settingsManager) {
+        return {
+            enabled: false,
+            baseDelayMs: DEFAULT_RECOVERY_BASE_DELAY_MS,
+            maxDelayMs: DEFAULT_RECOVERY_MAX_DELAY_MS,
+        };
+    }
+    const retry = settingsManager.getRetrySettings();
+    const provider = settingsManager.getProviderRetrySettings();
+    return {
+        enabled: retry.enabled,
+        baseDelayMs: Math.max(0, retry.baseDelayMs),
+        maxDelayMs: provider.maxRetryDelayMs > 0 ? provider.maxRetryDelayMs : DEFAULT_RECOVERY_MAX_DELAY_MS,
+    };
+}
+export function piboProviderRecoveryDelayMs(attempt, settings) {
+    const exponent = Math.max(0, Math.floor(attempt) - 1);
+    const uncapped = settings.baseDelayMs * 2 ** Math.min(exponent, 30);
+    return Math.min(settings.maxDelayMs, Number.isFinite(uncapped) ? uncapped : settings.maxDelayMs);
+}
+export function isRetryablePiboAssistantError(message) {
+    if (!message || typeof message !== "object")
+        return false;
+    const assistantMessage = message;
+    if (isRetryableAssistantError(assistantMessage))
+        return true;
+    return typeof assistantMessage.errorMessage === "string"
+        && classifySessionErrorMessage(assistantMessage.errorMessage, { hasProviderContext: true }).retryable === true;
+}
+export function isRetryablePiboProviderError(error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return isRetryablePiboAssistantError({ stopReason: "error", errorMessage });
+}
+export async function waitForPiboProviderRecovery(attempt, settings, signal) {
+    if (signal?.aborted)
+        throw new PiboProviderRecoveryCancelledError();
+    const delayMs = piboProviderRecoveryDelayMs(attempt, settings);
+    if (delayMs <= 0)
+        return;
+    await new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new PiboProviderRecoveryCancelledError());
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, delayMs);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/core/provider-telemetry.js

@@ -0,0 +1,353 @@
+import { randomUUID } from "node:crypto";
+import { BestEffortTelemetryService, } from "../data/telemetry.js";
+import { normalizeSessionErrorDetails } from "./session-errors.js";
+export class PiboProviderTelemetryRecorder {
+    options;
+    telemetry;
+    activeProviderRequestId;
+    constructor(options) {
+        this.options = options;
+        this.telemetry = new BestEffortTelemetryService(options.store, options.onError);
+    }
+    recordRequestStart(payload, options = {}) {
+        const capturedOptions = { ...options, at: options.at ?? new Date().toISOString() };
+        return this.schedule(() => this.recordRequestStartNow(providerPayloadSnapshot(payload), capturedOptions));
+    }
+    recordRequestStartNow(payload, options) {
+        if (!this.options.store)
+            return undefined;
+        try {
+            const turn = this.activeTurn();
+            if (!turn)
+                return undefined;
+            const now = options.at ?? new Date().toISOString();
+            if (this.activeProviderRequest()) {
+                this.finishActiveProviderRequest("aborted", now, "provider request superseded", undefined, "provider_superseded");
+            }
+            const model = modelInfo(options.model, this.options.model, payload);
+            const providerRequestId = `pr_${randomUUID()}`;
+            const phaseId = this.nextPhaseId(turn.turnId, "provider_request");
+            this.telemetry.upsertPhase({
+                phaseId,
+                turnId: turn.turnId,
+                piboSessionId: turn.piboSessionId,
+                rootSessionId: turn.rootSessionId,
+                roomId: turn.roomId,
+                name: "provider_request",
+                status: "open",
+                startedAt: now,
+                lastProgressAt: now,
+                providerRequestId,
+                eventId: turn.eventId ?? turn.inputEventId,
+                summary: "provider request started",
+            });
+            this.telemetry.upsertTurn({
+                turnId: turn.turnId,
+                piboSessionId: turn.piboSessionId,
+                rootSessionId: turn.rootSessionId,
+                roomId: turn.roomId,
+                eventId: turn.eventId ?? turn.inputEventId,
+                status: "running",
+                currentPhase: "provider_request",
+                lastProgressAt: now,
+                queueDepth: turn.queueDepth,
+                summary: "provider request started",
+            });
+            const request = this.telemetry.upsertProviderRequest({
+                providerRequestId,
+                piboSessionId: turn.piboSessionId,
+                rootSessionId: turn.rootSessionId,
+                roomId: turn.roomId,
+                turnId: turn.turnId,
+                phaseId,
+                provider: model.provider,
+                api: model.api,
+                model: model.id,
+                transport: "sse",
+                serviceTier: serviceTierFromPayload(payload),
+                status: "started",
+                startedAt: now,
+                captureMode: "metadata_only",
+            });
+            this.activeProviderRequestId = request?.providerRequestId ?? providerRequestId;
+            return request;
+        }
+        catch (error) {
+            this.options.onError?.(error);
+            return undefined;
+        }
+    }
+    recordResponse(input) {
+        const captured = { status: input.status, at: input.at ?? new Date().toISOString() };
+        return this.schedule(() => this.recordResponseNow(captured));
+    }
+    recordResponseNow(input) {
+        if (!this.options.store)
+            return undefined;
+        try {
+            const request = this.activeProviderRequest();
+            if (!request)
+                return undefined;
+            const now = input.at ?? new Date().toISOString();
+            this.telemetry.finishPhase(request.phaseId ?? `${request.turnId}:provider_request`, {
+                status: "ok",
+                endedAt: now,
+                lastProgressAt: now,
+                summary: "provider response received",
+            });
+            const streamPhaseId = providerStreamPhaseId(request);
+            this.telemetry.upsertPhase({
+                phaseId: streamPhaseId,
+                turnId: request.turnId,
+                piboSessionId: request.piboSessionId,
+                rootSessionId: request.rootSessionId,
+                roomId: request.roomId,
+                name: "provider_stream",
+                status: "open",
+                startedAt: now,
+                lastProgressAt: now,
+                providerRequestId: request.providerRequestId,
+                eventId: request.eventId,
+                summary: "provider response headers received",
+            });
+            this.telemetry.upsertTurn({
+                turnId: request.turnId,
+                piboSessionId: request.piboSessionId,
+                rootSessionId: request.rootSessionId,
+                roomId: request.roomId,
+                eventId: request.eventId,
+                status: "running",
+                currentPhase: "provider_stream",
+                lastProgressAt: now,
+                summary: "provider response received",
+            });
+            return this.updateProviderRequest(request, {
+                status: "headers",
+                responseHeadersAt: now,
+                firstByteAt: request.firstByteAt ?? now,
+                httpStatus: input.status,
+                phaseId: request.phaseId,
+            });
+        }
+        catch (error) {
+            this.options.onError?.(error);
+            return undefined;
+        }
+    }
+    // The assistant message boundary ends the provider stream even when the wider
+    // Pibo turn continues with a long-running tool or another provider request.
+    recordMessageEnd(message, options = {}) {
+        if (!isAssistantMessage(message))
+            return undefined;
+        const captured = providerAssistantMessageSnapshot(message);
+        const capturedOptions = { ...options, at: options.at ?? new Date().toISOString() };
+        return this.schedule(() => this.recordMessageEndNow(captured, capturedOptions));
+    }
+    recordMessageEndNow(message, options) {
+        if (!this.options.store)
+            return undefined;
+        const status = providerStatusForMessage(message);
+        const summary = providerSummaryForStatus(status);
+        const errorMessage = safeMessageError(message);
+        const errorDetails = status === "error"
+            ? normalizeSessionErrorDetails(errorMessage ?? "Provider request failed.", {
+                api: optionalString(message.api),
+                provider: optionalString(message.provider),
+                model: optionalString(message.model),
+            })
+            : undefined;
+        return this.finishActiveProviderRequest(status, options.at ?? new Date().toISOString(), summary, errorMessage, errorDetails?.category ?? errorDetails?.errorClass);
+    }
+    recordShutdown(reason, at = new Date().toISOString()) {
+        return this.schedule(() => this.finishActiveProviderRequest("aborted", at, reason, undefined, "runtime_abort"));
+    }
+    schedule(write) {
+        if (this.options.writer) {
+            this.options.writer.enqueue(write, this.options.onError);
+            return undefined;
+        }
+        return write();
+    }
+    finishActiveProviderRequest(status, now, summary, errorMessage, errorCategory) {
+        if (!this.options.store)
+            return undefined;
+        try {
+            const request = this.activeProviderRequest();
+            if (!request)
+                return undefined;
+            const phaseStatus = status === "completed" ? "ok" : status;
+            const requestPhaseId = request.phaseId ?? `${request.turnId}:provider_request`;
+            if (this.options.store.getPhase(requestPhaseId)?.status === "open") {
+                this.telemetry.finishPhase(requestPhaseId, { status: phaseStatus, endedAt: now, lastProgressAt: now, summary });
+            }
+            const streamPhaseId = providerStreamPhaseId(request);
+            if (this.options.store.getPhase(streamPhaseId)?.status === "open") {
+                this.telemetry.finishPhase(streamPhaseId, { status: phaseStatus, endedAt: now, lastProgressAt: now, summary });
+            }
+            const updated = this.updateProviderRequest(request, {
+                status,
+                completedAt: now,
+                errorCategory: status === "error" ? errorCategory ?? "provider_error" : status === "aborted" ? errorCategory ?? "runtime_abort" : undefined,
+                errorMessage,
+            });
+            this.activeProviderRequestId = undefined;
+            return updated;
+        }
+        catch (error) {
+            this.options.onError?.(error);
+            return undefined;
+        }
+    }
+    activeTurn() {
+        const detail = this.options.store?.getSessionTelemetry(this.options.session.id, { limit: 10 });
+        const active = detail?.activeTurn;
+        if (!active || (active.status !== "queued" && active.status !== "running"))
+            return undefined;
+        return active;
+    }
+    activeProviderRequest() {
+        if (this.activeProviderRequestId) {
+            const active = this.options.store?.getProviderRequest(this.activeProviderRequestId);
+            if (active && !isTerminalProviderStatus(active.status))
+                return active;
+        }
+        const turn = this.activeTurn();
+        if (!turn)
+            return undefined;
+        return this.options.store?.getActiveProviderRequestForTurn(turn.turnId);
+    }
+    nextPhaseId(turnId, phaseName) {
+        const count = this.options.store?.countPhasesForTurn(turnId, phaseName) ?? 0;
+        return count === 0 ? `${turnId}:${phaseName}` : `${turnId}:${phaseName}:${count + 1}`;
+    }
+    updateProviderRequest(existing, input) {
+        return this.telemetry.upsertProviderRequest({
+            providerRequestId: existing.providerRequestId,
+            piboSessionId: existing.piboSessionId,
+            rootSessionId: existing.rootSessionId,
+            roomId: existing.roomId,
+            turnId: existing.turnId,
+            phaseId: input.phaseId ?? existing.phaseId,
+            provider: existing.provider,
+            api: existing.api,
+            model: existing.model,
+            transport: existing.transport,
+            serviceTier: existing.serviceTier,
+            status: input.status ?? existing.status,
+            responseHeadersAt: input.responseHeadersAt,
+            firstByteAt: input.firstByteAt,
+            httpStatus: input.httpStatus,
+            completedAt: input.completedAt,
+            rawEventCount: existing.rawEventCount,
+            normalizedEventCount: existing.normalizedEventCount,
+            parseErrorCount: existing.parseErrorCount,
+            unknownEventCount: existing.unknownEventCount,
+            bytesReceived: existing.bytesReceived,
+            eventTypeCounts: existing.eventTypeCounts,
+            eventStreamId: existing.eventStreamId,
+            eventId: existing.eventId,
+            payloadRef: existing.payloadRef,
+            errorCategory: input.errorCategory,
+            errorMessage: input.errorMessage,
+            captureMode: existing.captureMode,
+            retentionClass: existing.retentionClass,
+        });
+    }
+}
+export function createPiboProviderTelemetryExtension(options) {
+    return (pi) => {
+        const recorder = new PiboProviderTelemetryRecorder(options);
+        pi.on("before_provider_request", (event, ctx) => {
+            recorder.recordRequestStart(event.payload, { model: modelFromContext(ctx) ?? options.model });
+        });
+        pi.on("after_provider_response", (event) => {
+            recorder.recordResponse({ status: event.status, headers: event.headers });
+        });
+        pi.on("message_end", (event) => {
+            recorder.recordMessageEnd(event.message);
+        });
+        pi.on("session_shutdown", (event) => {
+            recorder.recordShutdown(`provider session shutdown: ${event.reason}`);
+        });
+    };
+}
+export function isTerminalProviderStatus(status) {
+    return status === "completed" || status === "error" || status === "aborted" || status === "timeout";
+}
+function isAssistantMessage(message) {
+    return Boolean(message && typeof message === "object" && message.role === "assistant");
+}
+function providerStatusForMessage(message) {
+    if (message.stopReason === "error")
+        return "error";
+    if (message.stopReason === "aborted")
+        return "aborted";
+    return "completed";
+}
+function providerSummaryForStatus(status) {
+    if (status === "error")
+        return "provider stream failed";
+    if (status === "aborted")
+        return "provider stream aborted";
+    return "provider stream completed";
+}
+function providerStreamPhaseId(request) {
+    return `${request.turnId}:provider_stream:${request.providerRequestId}`;
+}
+function safeMessageError(message) {
+    return typeof message.errorMessage === "string" && message.errorMessage.trim().length > 0
+        ? message.errorMessage.replace(/\s+/g, " ").trim().slice(0, 512)
+        : undefined;
+}
+function optionalString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function modelInfo(primary, fallback, payload) {
+    const payloadModel = modelIdFromPayload(payload);
+    return {
+        provider: primary?.provider ?? fallback?.provider ?? "unknown",
+        id: primary?.id ?? fallback?.id ?? payloadModel ?? "unknown",
+        api: primary?.api ?? fallback?.api ?? "unknown",
+    };
+}
+function modelFromContext(ctx) {
+    const getModel = typeof ctx === "object" && ctx !== null && "getModel" in ctx ? ctx.getModel : undefined;
+    if (typeof getModel !== "function")
+        return undefined;
+    const model = getModel();
+    if (!model || typeof model !== "object")
+        return undefined;
+    const candidate = model;
+    const provider = typeof candidate.provider === "string" && candidate.provider.length > 0 ? candidate.provider : undefined;
+    const id = typeof candidate.id === "string" && candidate.id.length > 0 ? candidate.id : undefined;
+    const api = typeof candidate.api === "string" && candidate.api.length > 0 ? candidate.api : undefined;
+    return provider && id ? { provider, id, api } : undefined;
+}
+function providerAssistantMessageSnapshot(message) {
+    return {
+        role: message.role,
+        stopReason: message.stopReason,
+        errorMessage: message.errorMessage,
+        api: message.api,
+        provider: message.provider,
+        model: message.model,
+    };
+}
+function providerPayloadSnapshot(payload) {
+    return {
+        model: modelIdFromPayload(payload),
+        service_tier: serviceTierFromPayload(payload),
+    };
+}
+function modelIdFromPayload(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return undefined;
+    const value = payload.model;
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function serviceTierFromPayload(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return undefined;
+    const value = payload.service_tier ?? payload.serviceTier;
+    return typeof value === "string" && value.length > 0 ? value.slice(0, 128) : undefined;
+}