@pasko70/pibo 1.1.0 → 1.2.0

package/dist/core/model-defaults.js

@@ -1,6 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-export const DEFAULT_PIBO_MODEL_DEFAULTS_PATH = ".pibo/model-defaults.json";
+import { piboHomePath } from "./pibo-home.js";
+import { isPiboThinkingLevel } from "./thinking.js";
+export const DEFAULT_PIBO_MODEL_DEFAULTS_PATH = "model-defaults.json";
 export function selectRequestedModelProfile(profile, defaults = {}) {
     if (profile.model)
         return cloneModelProfile(profile.model);
@@ -8,8 +10,18 @@ export function selectRequestedModelProfile(profile, defaults = {}) {
         return cloneModelProfile(profile.subagentModel ?? defaults.subagent);
     return cloneModelProfile(profile.mainModel ?? defaults.main);
 }
-export function loadPiboModelDefaults(cwd = process.cwd(), path = DEFAULT_PIBO_MODEL_DEFAULTS_PATH) {
-    const resolvedPath = resolve(cwd, path);
+export function selectRequestedThinkingLevel(profile, defaults = {}) {
+    if (profile.parentSessionId)
+        return profile.subagentThinkingLevel ?? profile.thinkingLevel ?? defaults.subagentThinking ?? defaults.thinking;
+    return profile.mainThinkingLevel ?? profile.thinkingLevel ?? defaults.mainThinking ?? defaults.thinking;
+}
+export function selectRequestedFastMode(profile, defaults = {}) {
+    if (profile.parentSessionId)
+        return profile.subagentFast ?? profile.fast ?? defaults.subagentFast ?? defaults.fast;
+    return profile.mainFast ?? profile.fast ?? defaults.mainFast ?? defaults.fast;
+}
+export function loadPiboModelDefaults(cwd = process.cwd(), path) {
+    const resolvedPath = path ? resolve(cwd, path) : piboHomePath(DEFAULT_PIBO_MODEL_DEFAULTS_PATH);
     if (!existsSync(resolvedPath))
         return {};
     try {
@@ -20,9 +32,9 @@ export function loadPiboModelDefaults(cwd = process.cwd(), path = DEFAULT_PIBO_M
         return {};
     }
 }
-export function savePiboModelDefaults(defaults, cwd = process.cwd(), path = DEFAULT_PIBO_MODEL_DEFAULTS_PATH) {
+export function savePiboModelDefaults(defaults, cwd = process.cwd(), path) {
     const sanitized = sanitizePiboModelDefaults(defaults);
-    const resolvedPath = resolve(cwd, path);
+    const resolvedPath = path ? resolve(cwd, path) : piboHomePath(DEFAULT_PIBO_MODEL_DEFAULTS_PATH);
     mkdirSync(dirname(resolvedPath), { recursive: true });
     writeFileSync(resolvedPath, `${JSON.stringify(sanitized, null, 2)}\n`);
     return sanitized;
@@ -31,10 +43,37 @@ export function sanitizePiboModelDefaults(value) {
     const raw = value && typeof value === "object" && !Array.isArray(value)
         ? value
         : {};
-    return {
-        main: sanitizeModelProfile(raw.main),
-        subagent: sanitizeModelProfile(raw.subagent),
-    };
+    const sanitized = {};
+    const main = sanitizeModelProfile(raw.main);
+    const subagent = sanitizeModelProfile(raw.subagent);
+    const thinking = sanitizeThinkingLevel(raw.thinking);
+    const mainThinking = sanitizeThinkingLevel(raw.mainThinking);
+    const subagentThinking = sanitizeThinkingLevel(raw.subagentThinking);
+    const fast = sanitizeBoolean(raw.fast);
+    const mainFast = sanitizeBoolean(raw.mainFast);
+    const subagentFast = sanitizeBoolean(raw.subagentFast);
+    if (main)
+        sanitized.main = main;
+    if (subagent)
+        sanitized.subagent = subagent;
+    if (thinking)
+        sanitized.thinking = thinking;
+    if (mainThinking)
+        sanitized.mainThinking = mainThinking;
+    if (subagentThinking)
+        sanitized.subagentThinking = subagentThinking;
+    if (fast !== undefined)
+        sanitized.fast = fast;
+    if (mainFast !== undefined)
+        sanitized.mainFast = mainFast;
+    if (subagentFast !== undefined)
+        sanitized.subagentFast = subagentFast;
+    return sanitized;
+}
+export function sanitizeThinkingLevel(value) {
+    if (typeof value !== "string")
+        return undefined;
+    return isPiboThinkingLevel(value) ? value : undefined;
 }
 export function sanitizeModelProfile(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
@@ -51,3 +90,6 @@ export function sanitizeModelProfile(value) {
 function cloneModelProfile(model) {
     return model ? { ...model } : undefined;
 }
+function sanitizeBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}

package/dist/core/pibo-home.js

@@ -0,0 +1,8 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function getPiboHome() {
+    return process.env.PIBO_HOME || join(homedir(), ".pibo");
+}
+export function piboHomePath(...segments) {
+    return join(getPiboHome(), ...segments);
+}

package/dist/core/profiles.js

@@ -6,6 +6,12 @@ export class InitialSessionContext {
     model;
     mainModel;
     subagentModel;
+    thinkingLevel;
+    mainThinkingLevel;
+    subagentThinkingLevel;
+    fast;
+    mainFast;
+    subagentFast;
     skills;
     tools;
     subagents;
@@ -23,6 +29,12 @@ export class InitialSessionContext {
         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 ?? [])];
@@ -42,6 +54,12 @@ export class InitialSessionContextBuilder {
     model;
     mainModel;
     subagentModel;
+    thinkingLevel;
+    mainThinkingLevel;
+    subagentThinkingLevel;
+    fast;
+    mainFast;
+    subagentFast;
     skills = [];
     tools = [];
     subagents = [];
@@ -75,6 +93,30 @@ export class InitialSessionContextBuilder {
         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;
@@ -147,6 +189,12 @@ export class InitialSessionContextBuilder {
             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,

package/dist/core/provider-telemetry.js

@@ -0,0 +1,222 @@
+import { randomUUID } from "node:crypto";
+import { BestEffortTelemetryService, } from "../data/telemetry.js";
+export class PiboProviderTelemetryRecorder {
+    options;
+    telemetry;
+    activeProviderRequestId;
+    constructor(options) {
+        this.options = options;
+        this.telemetry = new BestEffortTelemetryService(options.store, options.onError);
+    }
+    recordRequestStart(payload, options = {}) {
+        if (!this.options.store)
+            return undefined;
+        try {
+            const turn = this.activeTurn();
+            if (!turn)
+                return undefined;
+            const now = options.at ?? new Date().toISOString();
+            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) {
+        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 = `${request.turnId}:provider_stream:${request.providerRequestId}`;
+            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;
+        }
+    }
+    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;
+        const timeline = this.options.store?.getTurnTimeline(turn.turnId, { limit: 100 });
+        return [...(timeline?.providerRequests ?? [])].reverse().find((request) => !isTerminalProviderStatus(request.status));
+    }
+    nextPhaseId(turnId, phaseName) {
+        const count = this.options.store?.getTurnTimeline(turnId, { limit: 100 })?.phases.filter((phase) => phase.name === phaseName).length ?? 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,
+            rawEventCount: existing.rawEventCount,
+            normalizedEventCount: existing.normalizedEventCount,
+            parseErrorCount: existing.parseErrorCount,
+            unknownEventCount: existing.unknownEventCount,
+            bytesReceived: existing.bytesReceived,
+            eventTypeCounts: existing.eventTypeCounts,
+            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 });
+        });
+    };
+}
+export function isTerminalProviderStatus(status) {
+    return status === "completed" || status === "error" || status === "aborted" || status === "timeout";
+}
+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 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;
+}