@pasko70/pibo 1.9.9 → 1.9.11

package/dist/core/session-router.js

@@ -0,0 +1,857 @@
+import { randomUUID } from "node:crypto";
+import { InitialSessionContext, } from "./profiles.js";
+import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault, selectDefaultPiboProfileName } from "../plugins/builtin.js";
+import { createPiboRuntime } from "./runtime.js";
+import { RoutedSession } from "./routed-session.js";
+import { runtimeSessionErrorDetails } from "./session-errors.js";
+import { createSubagentToolName } from "../subagents/tool.js";
+import { PiboRunRegistry } from "../runs/registry.js";
+import { createPiboSignalRegistry } from "../signals/registry.js";
+import { createDefaultPiboReliabilityStore } from "../reliability/store.js";
+import { InMemoryPiboSessionStore, } from "../sessions/store.js";
+import { getDefaultPiboWorkspace } from "./workspace.js";
+import { loadPiboModelDefaults, selectRequestedFastMode } from "./model-defaults.js";
+import { loadPiboUserSettings } from "./user-settings.js";
+import { resolvePiboSessionActiveModel } from "./session-model.js";
+import { isPiboThinkingLevel } from "./thinking.js";
+import { RuntimeSessionRegistry } from "../tools/runtime/registry.js";
+import { assertGatewayResourceAvailableForWork } from "./gateway-resource-guard.js";
+import { withWorkflowSessionKind } from "../sessions/workflow-session-kind.js";
+import { PiboRuntimeTelemetryRecorder } from "./runtime-telemetry.js";
+import { createPiboProviderTelemetryExtension } from "./provider-telemetry.js";
+import { AsyncTelemetryWriter } from "../data/telemetry-writer.js";
+const DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
+const DEFAULT_ROUTED_SESSION_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+export const RALPH_RUNTIME_RETRY_DEFAULTS = {
+    enabled: true,
+    maxRetries: 7,
+    baseDelayMs: 2_000,
+};
+export function resolvePiboSessionRetryDefaults(kind, configured) {
+    return configured ?? (kind === "ralph" ? RALPH_RUNTIME_RETRY_DEFAULTS : undefined);
+}
+export function resolvePiboSessionInitialThinkingLevel(session) {
+    const value = session.metadata?.initialThinkingLevel;
+    return typeof value === "string" && isPiboThinkingLevel(value) ? value : undefined;
+}
+export function resolvePiboSessionInitialFastMode(session) {
+    const value = session.metadata?.initialFastMode;
+    return typeof value === "boolean" ? value : undefined;
+}
+function profileForSession(baseProfile, piSessionId, parentPiSessionId) {
+    const options = {
+        profileName: baseProfile.profileName,
+        sessionId: piSessionId,
+        parentSessionId: parentPiSessionId,
+        model: baseProfile.model,
+        mainModel: baseProfile.mainModel,
+        subagentModel: baseProfile.subagentModel,
+        thinkingLevel: baseProfile.thinkingLevel,
+        mainThinkingLevel: baseProfile.mainThinkingLevel,
+        subagentThinkingLevel: baseProfile.subagentThinkingLevel,
+        fast: baseProfile.fast,
+        mainFast: baseProfile.mainFast,
+        subagentFast: baseProfile.subagentFast,
+        skills: baseProfile.skills,
+        tools: baseProfile.tools,
+        subagents: baseProfile.subagents,
+        mcpServers: baseProfile.mcpServers,
+        contextFiles: baseProfile.contextFiles,
+        piPackages: baseProfile.piPackages,
+        builtinTools: baseProfile.builtinTools,
+        builtinToolNames: baseProfile.builtinToolNames,
+        autoContextFiles: baseProfile.autoContextFiles,
+        toolPackages: baseProfile.toolPackages,
+    };
+    return new InitialSessionContext(options);
+}
+function formatRunReminderMessage(notification) {
+    return [
+        "<pibo_run_notification>",
+        JSON.stringify({
+            completed: notification.completed.map((run) => ({
+                runId: run.runId,
+                kind: run.kind,
+                status: run.status,
+                toolName: run.toolName,
+                summary: run.summary,
+            })),
+            failed: notification.failed.map((run) => ({
+                runId: run.runId,
+                kind: run.kind,
+                status: run.status,
+                toolName: run.toolName,
+                summary: run.summary,
+            })),
+            cancelled: notification.cancelled.map((run) => ({
+                runId: run.runId,
+                kind: run.kind,
+                status: run.status,
+                toolName: run.toolName,
+                summary: run.summary,
+            })),
+            running: notification.running.map((run) => ({
+                runId: run.runId,
+                kind: run.kind,
+                status: run.status,
+                toolName: run.toolName,
+                summary: run.summary,
+            })),
+            instruction: "Use pibo_run_read for completed or failed runs. Use pibo_run_wait, pibo_run_status, pibo_run_cancel, or pibo_run_ack for runs you still need to manage.",
+        }),
+        "</pibo_run_notification>",
+    ].join("\n");
+}
+function isRunReminderServiceMessage(event) {
+    return event.source === "service" && event.text.startsWith("<pibo_run_notification>");
+}
+function isTerminalRunStatus(status) {
+    return status === "completed" || status === "failed" || status === "cancelled";
+}
+function asJsonObject(value) {
+    return value ?? {};
+}
+function shouldResetSessionAfterAction(action) {
+    return action === "login.complete" || action === "login.apikey" || action === "logout";
+}
+function piboRoomIdFromMetadata(metadata) {
+    const value = metadata?.chatRoomId;
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function telemetryStoreFromSessionStore(store) {
+    return store.getTelemetryStore?.();
+}
+function providerEventTelemetryModeFromEnv(env = process.env) {
+    const value = env.PIBO_TELEMETRY_PROVIDER_EVENTS?.trim().toLowerCase();
+    return value === "1" || value === "true" || value === "detailed" ? "detailed" : "aggregate";
+}
+export class PiboSessionRouter {
+    options;
+    sessions = new Map();
+    pendingSessions = new Map();
+    listeners = new Set();
+    runRegistry;
+    signalRegistry;
+    runtimeRegistry;
+    scheduledRunReminders = new Map();
+    idleSessionTimers = new Map();
+    routedSessionIdleTimeoutMs;
+    baseProfile;
+    pluginRegistry;
+    sessionStore;
+    reliabilityStore;
+    telemetryStore;
+    telemetryWriter;
+    telemetryRecorder;
+    disposePromise;
+    closing = false;
+    constructor(options = {}) {
+        this.options = options;
+        this.pluginRegistry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
+        this.sessionStore = options.sessionStore ?? new InMemoryPiboSessionStore();
+        this.telemetryStore = options.telemetryStore ?? telemetryStoreFromSessionStore(this.sessionStore);
+        this.telemetryWriter = this.telemetryStore ? new AsyncTelemetryWriter(this.telemetryStore) : undefined;
+        this.telemetryRecorder = this.telemetryStore
+            ? new PiboRuntimeTelemetryRecorder(this.telemetryStore, undefined, {
+                providerEventMode: providerEventTelemetryModeFromEnv(),
+                writer: this.telemetryWriter,
+            })
+            : undefined;
+        const idleTimeoutMs = options.routedSessionIdleTimeoutMs;
+        this.routedSessionIdleTimeoutMs = idleTimeoutMs === false
+            ? false
+            : typeof idleTimeoutMs === "number" && Number.isFinite(idleTimeoutMs) && idleTimeoutMs > 0
+                ? idleTimeoutMs
+                : DEFAULT_ROUTED_SESSION_IDLE_TIMEOUT_MS;
+        const defaultProfileName = selectDefaultPiboProfileName(this.pluginRegistry);
+        this.baseProfile = options.profile ?? createPiboProfileFromRegistryOrDefault(this.pluginRegistry, defaultProfileName);
+        this.reliabilityStore = options.reliabilityStore ?? (options.persistSession === false ? undefined : createDefaultPiboReliabilityStore());
+        this.signalRegistry = options.signalRegistry ?? createPiboSignalRegistry();
+        this.runtimeRegistry = new RuntimeSessionRegistry({ cwd: options.cwd ?? getDefaultPiboWorkspace() });
+        this.runRegistry = new PiboRunRegistry({ store: this.reliabilityStore });
+        this.runRegistry.subscribe((event) => this.projectRunRegistryEvent(event));
+        for (const run of this.runRegistry.listAll({ includeConsumed: true, includeDetached: true })) {
+            this.signalRegistry.project({ type: "run_changed", run, reason: "recovered" });
+        }
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    async emit(event) {
+        if (this.closing)
+            throw new Error("Pibo session router is disposed.");
+        if (event.type === "message" && event.id) {
+            const stored = this.sessionStore.get(event.piboSessionId);
+            if (stored)
+                this.signalRegistry.project({ type: "session_created", session: stored });
+            this.signalRegistry.project({ type: "message_accepted", piboSessionId: event.piboSessionId, eventId: event.id, source: event.source });
+        }
+        let session;
+        try {
+            session = await this.getOrCreateSession(event.piboSessionId);
+        }
+        catch (error) {
+            if (event.type === "message" && event.id) {
+                this.signalRegistry.project({
+                    type: "pibo_output",
+                    event: {
+                        type: "session_error",
+                        piboSessionId: event.piboSessionId,
+                        eventId: event.id,
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            }
+            throw error;
+        }
+        this.clearIdleSessionTimer(event.piboSessionId);
+        try {
+            if (event.type === "message") {
+                return session.enqueueMessage(event);
+            }
+            if (event.action === "abort") {
+                this.signalRegistry.project({ type: "session_interrupted", piboSessionId: event.piboSessionId, reason: "abort action" });
+            }
+            else if (event.action === "dispose" || event.action === "kill" || event.action === "kill_all") {
+                this.signalRegistry.project({ type: "session_disposed", piboSessionId: event.piboSessionId, reason: `${event.action} action` });
+            }
+            const output = await session.executeAction(event);
+            if (event.action === "dispose") {
+                await this.disposeSessionSubtree(event.piboSessionId, "dispose action", { cancelRuns: true });
+            }
+            else if (event.action === "kill" || event.action === "kill_all") {
+                await this.disposeSessionSubtree(event.piboSessionId, `${event.action} action`, { cancelRuns: event.action === "kill_all" });
+            }
+            else if (shouldResetSessionAfterAction(event.action)) {
+                await this.resetCachedSession(event.piboSessionId, "provider auth changed");
+            }
+            return output;
+        }
+        finally {
+            this.scheduleIdleSessionEvictionIfIdle(event.piboSessionId);
+        }
+    }
+    async killSession(piboSessionId, options) {
+        const killed = [];
+        const cancelledRuns = [];
+        const session = this.sessions.get(piboSessionId);
+        if (session) {
+            this.signalRegistry.project({ type: "session_disposed", piboSessionId, reason: "kill" });
+            killed.push(await session.kill());
+            if (options?.includeRuns) {
+                const runs = this.runRegistry.cancelControllerRuns(piboSessionId);
+                cancelledRuns.push(...runs.map((r) => r.runId));
+            }
+            const children = await this.killChildSessions(piboSessionId, options);
+            killed.push(...children.killed);
+            cancelledRuns.push(...children.cancelledRuns);
+            await this.disposeSessionSubtree(piboSessionId, "kill", { cancelRuns: false });
+        }
+        return { killed, cancelledRuns };
+    }
+    async disposeSessionSubtree(piboSessionId, reason, options) {
+        const ids = [piboSessionId, ...this.descendantSessionIds(piboSessionId)];
+        const sessions = [];
+        for (const id of ids) {
+            if (options.cancelRuns)
+                this.runRegistry.cancelControllerRuns(id);
+            this.clearIdleSessionTimer(id);
+            this.scheduledRunReminders.delete(id);
+            const cached = this.sessions.get(id);
+            if (cached)
+                sessions.push(cached);
+            this.sessions.delete(id);
+        }
+        try {
+            await Promise.all(ids.map((id) => this.runtimeRegistry.closeControllerSessions(id, { force: true })));
+            await Promise.all(sessions.map((session) => session.dispose()));
+        }
+        finally {
+            await this.telemetryWriter?.flush();
+        }
+        for (const id of ids) {
+            this.signalRegistry.project({ type: "session_disposed", piboSessionId: id, reason });
+        }
+    }
+    descendantSessionIds(parentId) {
+        const output = [];
+        for (const session of this.sessionStore.list?.() ?? []) {
+            if (session.parentId !== parentId)
+                continue;
+            output.push(session.id, ...this.descendantSessionIds(session.id));
+        }
+        return output;
+    }
+    async killChildSessions(parentId, options) {
+        const killed = [];
+        const cancelledRuns = [];
+        const allSessions = this.sessionStore.list?.() ?? [];
+        for (const session of allSessions) {
+            if (session.parentId === parentId) {
+                const childSession = this.sessions.get(session.id);
+                if (childSession) {
+                    killed.push(await childSession.kill());
+                }
+                if (options?.includeRuns) {
+                    const runs = this.runRegistry.cancelControllerRuns(session.id);
+                    cancelledRuns.push(...runs.map((r) => r.runId));
+                }
+                const nested = await this.killChildSessions(session.id, options);
+                killed.push(...nested.killed);
+                cancelledRuns.push(...nested.cancelledRuns);
+            }
+        }
+        return { killed, cancelledRuns };
+    }
+    getPiboSessionIds() {
+        return [...this.sessions.keys()];
+    }
+    getSessionRuntimeStatus(piboSessionId) {
+        return this.sessions.get(piboSessionId)?.getStatus();
+    }
+    async setLiveSessionActiveModel(piboSessionId, model) {
+        const session = this.sessions.get(piboSessionId);
+        if (!session)
+            return model;
+        const status = session.getStatus();
+        if (status.processing || status.streaming || status.queuedMessages > 0) {
+            throw new Error("Session model can only be changed while the runtime is idle.");
+        }
+        if (!model) {
+            await this.resetCachedSession(piboSessionId);
+            return undefined;
+        }
+        return session.setModel(model);
+    }
+    reportSessionError(piboSessionId, error, options = {}) {
+        this.signalRegistry.project({ type: "session_created", session: this.resolvePiboSession(piboSessionId) });
+        this.emitOutput({
+            type: "session_error",
+            piboSessionId,
+            eventId: options.eventId,
+            error,
+            errorDetails: runtimeSessionErrorDetails(error),
+        });
+    }
+    listSessionRuntimeStatuses() {
+        return [...this.sessions.values()].map((session) => session.getStatus());
+    }
+    listRuns(options = {}) {
+        return this.runRegistry.listAll(options);
+    }
+    getSignalRegistry() {
+        return this.signalRegistry;
+    }
+    snapshotSignalSession(piboSessionId) {
+        this.projectKnownSessionSignals();
+        return this.signalRegistry.snapshotSession(piboSessionId);
+    }
+    snapshotSignalTree(rootPiboSessionId) {
+        this.projectKnownSessionSignals();
+        return this.signalRegistry.snapshotTree(rootPiboSessionId);
+    }
+    snapshotSignalStatuses() {
+        this.projectKnownSessionSignals();
+        return this.signalRegistry.snapshotStatuses();
+    }
+    subscribeSignalTree(rootPiboSessionId, listener) {
+        return this.signalRegistry.subscribe(rootPiboSessionId, listener);
+    }
+    subscribeSignalStatuses(listener) {
+        return this.signalRegistry.subscribeAll(listener);
+    }
+    async emitMessageAndWaitForReply(event, timeoutMs = 120000) {
+        const eventWithId = { ...event, id: event.id ?? randomUUID() };
+        return await new Promise((resolve, reject) => {
+            let settled = false;
+            let lastAssistantMessage;
+            let timeout;
+            const unsubscribe = this.subscribe((output) => {
+                if (output.piboSessionId !== eventWithId.piboSessionId ||
+                    !("eventId" in output) ||
+                    output.eventId !== eventWithId.id) {
+                    return;
+                }
+                if (output.type === "assistant_message") {
+                    lastAssistantMessage = output;
+                }
+                else if (output.type === "message_finished") {
+                    finish(lastAssistantMessage ?? new Error(`Pibo session "${eventWithId.piboSessionId}" finished without an assistant reply`));
+                }
+                else if (output.type === "session_error") {
+                    finish(new Error(output.error));
+                }
+            });
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeout)
+                    clearTimeout(timeout);
+                unsubscribe();
+                if (result instanceof Error) {
+                    reject(result);
+                }
+                else {
+                    resolve(result);
+                }
+            };
+            timeout = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                unsubscribe();
+                const timeoutError = new Error(`Timed out waiting for assistant reply from Pibo session "${eventWithId.piboSessionId}"`);
+                reject(timeoutError);
+                void this.emit({
+                    type: "execution",
+                    piboSessionId: eventWithId.piboSessionId,
+                    action: "abort",
+                    id: randomUUID(),
+                }).catch(() => { });
+            }, timeoutMs);
+            this.emit(eventWithId).catch(finish);
+        });
+    }
+    async disposeAll() {
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.closing = true;
+        this.disposePromise = this.disposeAllUnsafe();
+        return this.disposePromise;
+    }
+    async disposeAllUnsafe() {
+        try {
+            await Promise.allSettled([...this.pendingSessions.values()]);
+            const sessions = [...this.sessions.values()];
+            this.sessions.clear();
+            for (const timer of this.idleSessionTimers.values())
+                clearTimeout(timer);
+            this.idleSessionTimers.clear();
+            this.runRegistry.cancelAll("Pibo session router was disposed.");
+            for (const session of sessions)
+                this.signalRegistry.project({ type: "session_disposed", piboSessionId: session.getStatus().piboSessionId, reason: "router disposed" });
+            this.scheduledRunReminders.clear();
+            await this.runtimeRegistry.closeAll({ force: true });
+            await Promise.all(sessions.map((session) => session.dispose()));
+        }
+        finally {
+            await this.telemetryWriter?.dispose();
+        }
+    }
+    clearIdleSessionTimer(piboSessionId) {
+        const timer = this.idleSessionTimers.get(piboSessionId);
+        if (timer)
+            clearTimeout(timer);
+        this.idleSessionTimers.delete(piboSessionId);
+    }
+    scheduleIdleSessionEvictionIfIdle(piboSessionId) {
+        if (this.routedSessionIdleTimeoutMs === false)
+            return;
+        const session = this.sessions.get(piboSessionId);
+        if (!session)
+            return;
+        const status = session.getStatus();
+        if (status.disposed || status.processing || status.streaming || status.queuedMessages > 0) {
+            this.clearIdleSessionTimer(piboSessionId);
+            return;
+        }
+        this.clearIdleSessionTimer(piboSessionId);
+        const timer = setTimeout(() => {
+            this.idleSessionTimers.delete(piboSessionId);
+            void this.evictIdleSession(piboSessionId, session).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                this.emitOutput({
+                    type: "session_error",
+                    piboSessionId,
+                    error: `Failed to dispose idle routed runtime: ${message}`,
+                    errorDetails: runtimeSessionErrorDetails(message),
+                });
+            });
+        }, this.routedSessionIdleTimeoutMs);
+        timer.unref();
+        this.idleSessionTimers.set(piboSessionId, timer);
+    }
+    async evictIdleSession(piboSessionId, expected) {
+        const current = this.sessions.get(piboSessionId);
+        if (current !== expected)
+            return;
+        const status = current.getStatus();
+        if (status.disposed || status.processing || status.streaming || status.queuedMessages > 0)
+            return;
+        await this.resetCachedSession(piboSessionId, "routed runtime idle timeout");
+    }
+    async getOrCreateSession(piboSessionId) {
+        if (this.closing)
+            throw new Error("Pibo session router is disposed.");
+        const existing = this.sessions.get(piboSessionId);
+        if (existing) {
+            this.clearIdleSessionTimer(piboSessionId);
+            return existing;
+        }
+        const pending = this.pendingSessions.get(piboSessionId);
+        if (pending)
+            return pending;
+        const created = this.createRoutedSession(piboSessionId);
+        this.pendingSessions.set(piboSessionId, created);
+        try {
+            return await created;
+        }
+        finally {
+            this.pendingSessions.delete(piboSessionId);
+        }
+    }
+    async createRoutedSession(piboSessionId) {
+        const piboSession = this.resolvePiboSession(piboSessionId);
+        this.signalRegistry.project({ type: "session_created", session: piboSession });
+        const profile = createPiboProfileFromRegistryOrDefault(this.pluginRegistry, piboSession.profile);
+        const parentPiSessionId = piboSession.parentId
+            ? this.resolvePiboSession(piboSession.parentId).piSessionId
+            : undefined;
+        const modelDefaults = this.resolveModelDefaults();
+        const activeModel = this.ensureSessionActiveModel(piboSession, profile, parentPiSessionId, modelDefaults);
+        const initialThinkingLevel = resolvePiboSessionInitialThinkingLevel(piboSession);
+        const userSettings = loadPiboUserSettings();
+        const telemetryExtension = this.telemetryStore
+            ? createPiboProviderTelemetryExtension({ store: this.telemetryStore, writer: this.telemetryWriter, session: piboSession, model: activeModel })
+            : undefined;
+        const runtime = await createPiboRuntime({
+            cwd: piboSession.workspace ?? this.options.cwd,
+            persistSession: this.options.persistSession,
+            thinkingLevel: initialThinkingLevel ?? this.options.thinkingLevel,
+            retryDefaults: resolvePiboSessionRetryDefaults(piboSession.kind, this.options.retryDefaults),
+            profile: profileForSession(profile, piboSession.piSessionId, parentPiSessionId),
+            extensionFactories: [
+                ...(telemetryExtension ? [telemetryExtension] : []),
+                ...(this.options.extensionFactories ?? []),
+            ],
+            subagentRunner: this.createSubagentRunner(piboSession.id),
+            runToolController: this.createRunToolController(piboSession.id),
+            runtimeToolController: this.runtimeRegistry.createController(piboSession.id),
+            modelDefaults,
+            activeModel,
+            sessionContext: {
+                piboSessionId: piboSession.id,
+                piboRoomId: piboRoomIdFromMetadata(piboSession.metadata),
+                timezone: userSettings.timezone,
+            },
+        });
+        const initialFastMode = resolvePiboSessionInitialFastMode(piboSession) ?? selectRequestedFastMode(profileForSession(profile, piboSession.piSessionId, parentPiSessionId), modelDefaults) ?? false;
+        const session = new RoutedSession(piboSession.id, runtime, this.emitOutput, this.pluginRegistry, this.options.forwardPiEvents ?? false, this.telemetryRecorder
+            ? (id, event, context) => this.telemetryRecorder?.recordPiEvent(id, event, { session: this.sessionStore.get(id), status: context.status, activeEventId: context.activeEventId })
+            : undefined, initialFastMode, (result, event) => this.handleSessionOperation(result, event), (id, opts) => this.killChildSessions(id, opts), (state) => {
+            this.signalRegistry.project({ type: "session_processing_changed", piboSessionId: piboSession.id, processing: state.processing, queuedMessages: state.queuedMessages });
+            if (state.disposed || state.processing || state.queuedMessages > 0)
+                this.clearIdleSessionTimer(piboSession.id);
+            else
+                this.scheduleIdleSessionEvictionIfIdle(piboSession.id);
+        }, (messages, reason) => this.telemetryRecorder?.recordMessagesInterrupted(messages, {
+            session: this.sessionStore.get(piboSession.id),
+            status: this.sessions.get(piboSession.id)?.getStatus(),
+        }, reason));
+        this.sessions.set(piboSession.id, session);
+        return session;
+    }
+    ensureSessionActiveModel(piboSession, profile, parentPiSessionId, modelDefaults) {
+        const activeModel = resolvePiboSessionActiveModel({
+            profile,
+            piboSession,
+            parentPiSessionId,
+            modelDefaults,
+        });
+        if (!piboSession.activeModel && activeModel) {
+            this.sessionStore.update(piboSession.id, { activeModel });
+        }
+        return activeModel;
+    }
+    resolveModelDefaults() {
+        if (typeof this.options.modelDefaults === "function")
+            return this.options.modelDefaults();
+        if (this.options.modelDefaults)
+            return this.options.modelDefaults;
+        return loadPiboModelDefaults(this.options.cwd ?? process.cwd());
+    }
+    async handleSessionOperation(result, event) {
+        if (result.cancelled)
+            return;
+        if (event.action === "session.fork" || event.action === "session.clone") {
+            const action = event.action;
+            const created = this.createDerivedSession(result, action);
+            result.piboSessionId = created.id;
+            await this.resetCachedSession(event.piboSessionId);
+            return;
+        }
+        this.sessionStore.update(event.piboSessionId, {
+            piSessionId: result.current.piSessionId,
+            workspace: result.current.cwd,
+        });
+    }
+    createDerivedSession(result, action) {
+        const source = this.resolvePiboSession(result.piboSessionId);
+        return this.sessionStore.create({
+            channel: source.channel,
+            kind: "branch",
+            profile: source.profile,
+            parentId: source.kind === "subagent" ? source.parentId : undefined,
+            originId: source.id,
+            piSessionId: result.current.piSessionId,
+            workspace: result.current.cwd,
+            title: source.title,
+            activeModel: source.activeModel,
+            metadata: {
+                ...asJsonObject(source.metadata),
+                originAction: action,
+                originPiSessionId: result.previous.piSessionId,
+            },
+        });
+    }
+    async resetCachedSession(piboSessionId, reason) {
+        const cached = this.sessions.get(piboSessionId);
+        this.clearIdleSessionTimer(piboSessionId);
+        this.sessions.delete(piboSessionId);
+        try {
+            await this.runtimeRegistry.closeControllerSessions(piboSessionId, { force: true });
+            await cached?.dispose();
+        }
+        finally {
+            await this.telemetryWriter?.flush();
+        }
+        if (reason)
+            this.signalRegistry.project({ type: "session_disposed", piboSessionId, reason });
+    }
+    resolvePiboSession(piboSessionId) {
+        const existing = this.sessionStore.get(piboSessionId);
+        if (existing)
+            return existing;
+        const created = this.sessionStore.create({
+            id: piboSessionId,
+            channel: "pibo.runtime",
+            kind: "runtime",
+            profile: this.baseProfile.profileName,
+            workspace: this.options.cwd ?? getDefaultPiboWorkspace(),
+        });
+        this.signalRegistry.project({ type: "session_created", session: created });
+        return created;
+    }
+    createSubagentRunner(parentPiboSessionId) {
+        return {
+            runSubagent: async ({ subagent, message, threadKey, toolCallId }) => {
+                this.assertSubagentDepth(parentPiboSessionId, subagent);
+                const child = this.resolveSubagentSession(parentPiboSessionId, subagent, threadKey);
+                const toolName = createSubagentToolName(subagent.name);
+                const event = {
+                    type: "message",
+                    piboSessionId: child.id,
+                    text: message,
+                    source: "actor",
+                    id: randomUUID(),
+                };
+                this.emitOutput({
+                    type: "subagent_session",
+                    piboSessionId: parentPiboSessionId,
+                    toolCallId,
+                    toolName,
+                    subagentName: subagent.name,
+                    childPiboSessionId: child.id,
+                    threadKey: typeof child.metadata?.threadKey === "string" ? child.metadata.threadKey : undefined,
+                });
+                const reply = await this.emitMessageAndWaitForReply(event, subagent.timeoutMs ?? DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS);
+                return { piboSessionId: child.id, eventId: event.id, reply };
+            },
+        };
+    }
+    createRunToolController(parentPiboSessionId) {
+        return {
+            startToolRun: ({ toolName, params, completionPolicy, retryable, maxAttempts, execute }) => {
+                assertGatewayResourceAvailableForWork(`yielded run ${toolName}`);
+                const run = this.runRegistry.startToolRun({
+                    controllerPiboSessionId: parentPiboSessionId,
+                    toolName,
+                    params,
+                    completionPolicy,
+                    retryable,
+                    maxAttempts,
+                });
+                void (async () => {
+                    try {
+                        const result = await execute();
+                        const completed = this.runRegistry.complete(run.runId, result);
+                        if (completed)
+                            this.scheduleRunReminder(parentPiboSessionId, false);
+                    }
+                    catch (error) {
+                        const failed = this.runRegistry.fail(run.runId, error instanceof Error ? error.message : String(error));
+                        if (failed)
+                            this.scheduleRunReminder(parentPiboSessionId, false);
+                    }
+                })();
+                return run;
+            },
+            listRuns: (options) => this.runRegistry.list(parentPiboSessionId, options),
+            getRunStatus: (runId) => this.runRegistry.status(parentPiboSessionId, runId),
+            waitForRun: (runId, timeoutMs) => this.runRegistry.wait(parentPiboSessionId, runId, timeoutMs),
+            readRun: (runId) => {
+                const run = this.runRegistry.read(parentPiboSessionId, runId);
+                if (run.consumed && isTerminalRunStatus(run.status)) {
+                    this.refreshQueuedRunReminders(parentPiboSessionId);
+                }
+                return run;
+            },
+            cancelRun: async (runId) => {
+                const cancelled = this.runRegistry.cancel(parentPiboSessionId, runId);
+                this.refreshQueuedRunReminders(parentPiboSessionId);
+                return cancelled;
+            },
+            ackRun: (runId) => {
+                const run = this.runRegistry.ack(parentPiboSessionId, runId);
+                this.refreshQueuedRunReminders(parentPiboSessionId);
+                return run;
+            },
+        };
+    }
+    assertSubagentDepth(parentPiboSessionId, subagent) {
+        const maxDepth = subagent.maxDepth ?? 3;
+        if (this.getSubagentDepth(parentPiboSessionId) >= maxDepth) {
+            throw new Error(`Subagent "${subagent.name}" exceeded max depth ${maxDepth} from Pibo session "${parentPiboSessionId}"`);
+        }
+    }
+    getSubagentDepth(piboSessionId) {
+        let depth = 0;
+        let current = this.sessionStore.get(piboSessionId);
+        const seen = new Set();
+        while (current?.parentId) {
+            if (seen.has(current.parentId))
+                break;
+            seen.add(current.parentId);
+            depth += 1;
+            current = this.sessionStore.get(current.parentId);
+        }
+        return depth;
+    }
+    resolveSubagentSession(parentPiboSessionId, subagent, threadKey) {
+        const targetProfile = resolvePiboProfileNameFromRegistryOrDefault(this.pluginRegistry, subagent.targetProfile);
+        const parent = this.resolvePiboSession(parentPiboSessionId);
+        const resolvedThreadKey = threadKey?.trim() ? threadKey.trim() : randomUUID();
+        const baseMetadata = {
+            subagentName: subagent.name,
+            subagentToolName: createSubagentToolName(subagent.name),
+            threadKey: resolvedThreadKey,
+        };
+        const metadata = withWorkflowSessionKind(baseMetadata, "subagent");
+        const parentChatRoomId = typeof parent.metadata?.chatRoomId === "string" ? parent.metadata.chatRoomId : undefined;
+        if (parentChatRoomId)
+            metadata.chatRoomId = parentChatRoomId;
+        const legacyMetadata = { ...baseMetadata };
+        const legacyMetadataWithChatRoom = parentChatRoomId
+            ? { ...baseMetadata, chatRoomId: parentChatRoomId }
+            : undefined;
+        const findExisting = (candidate) => candidate
+            ? this.sessionStore.find({
+                channel: "pibo.subagents",
+                kind: "subagent",
+                parentId: parent.id,
+                profile: targetProfile,
+                metadata: candidate,
+            })[0]
+            : undefined;
+        const existing = findExisting(metadata) ?? findExisting(legacyMetadataWithChatRoom) ?? findExisting(legacyMetadata);
+        if (existing) {
+            const updatedMetadata = withWorkflowSessionKind({
+                ...(existing.metadata ?? {}),
+                ...(parentChatRoomId ? { chatRoomId: parentChatRoomId } : {}),
+            }, "subagent");
+            if (JSON.stringify(updatedMetadata) !== JSON.stringify(existing.metadata ?? {})) {
+                return this.sessionStore.update(existing.id, { metadata: updatedMetadata }) ?? existing;
+            }
+            return existing;
+        }
+        const childProfile = createPiboProfileFromRegistryOrDefault(this.pluginRegistry, targetProfile);
+        const childSession = this.sessionStore.create({
+            channel: "pibo.subagents",
+            kind: "subagent",
+            profile: targetProfile,
+            parentId: parent.id,
+            workspace: parent.workspace,
+            metadata,
+        });
+        this.signalRegistry.project({ type: "session_created", session: childSession });
+        const activeModel = resolvePiboSessionActiveModel({
+            profile: childProfile,
+            piboSession: childSession,
+            parentPiSessionId: parent.piSessionId,
+            modelDefaults: this.resolveModelDefaults(),
+        });
+        return activeModel ? this.sessionStore.update(childSession.id, { activeModel }) ?? childSession : childSession;
+    }
+    emitOutput = (event) => {
+        const session = this.sessionStore.get(event.piboSessionId);
+        this.telemetryRecorder?.recordOutput(event, { session, status: this.sessions.get(event.piboSessionId)?.getStatus() });
+        this.signalRegistry.project({ type: "pibo_output", event, session });
+        this.pluginRegistry.notifyEvent(event);
+        for (const listener of this.listeners) {
+            listener(event);
+        }
+        if (event.type === "message_finished" && event.source !== "service") {
+            this.scheduleRunReminder(event.piboSessionId, true);
+        }
+    };
+    projectKnownSessionSignals() {
+        for (const session of this.sessionStore.list?.() ?? []) {
+            this.signalRegistry.project({ type: "session_created", session });
+        }
+    }
+    projectRunRegistryEvent(event) {
+        if (event.type === "run_removed") {
+            this.signalRegistry.project({ type: "run_removed", runId: event.runId, controllerPiboSessionId: event.controllerPiboSessionId });
+            return;
+        }
+        this.signalRegistry.project({ type: "run_changed", run: event.run, previousStatus: "previousStatus" in event ? event.previousStatus : undefined, reason: "reason" in event ? event.reason : event.type });
+    }
+    scheduleRunReminder(piboSessionId, includeAlreadyNotified) {
+        if (!this.runRegistry.hasPendingNotification(piboSessionId, { includeAlreadyNotified }))
+            return;
+        const previous = this.scheduledRunReminders.get(piboSessionId);
+        if (previous !== undefined) {
+            this.scheduledRunReminders.set(piboSessionId, previous || includeAlreadyNotified);
+            return;
+        }
+        this.scheduledRunReminders.set(piboSessionId, includeAlreadyNotified);
+        queueMicrotask(() => {
+            void this.deliverRunReminder(piboSessionId);
+        });
+    }
+    refreshQueuedRunReminders(piboSessionId) {
+        const removed = this.sessions.get(piboSessionId)?.removeQueuedMessages(isRunReminderServiceMessage) ?? 0;
+        if (removed > 0)
+            this.scheduleRunReminder(piboSessionId, true);
+    }
+    async deliverRunReminder(piboSessionId) {
+        const includeAlreadyNotified = this.scheduledRunReminders.get(piboSessionId) ?? false;
+        this.scheduledRunReminders.delete(piboSessionId);
+        const notification = this.runRegistry.createNotification(piboSessionId, { includeAlreadyNotified });
+        if (!notification)
+            return;
+        try {
+            const session = await this.getOrCreateSession(piboSessionId);
+            session.enqueueMessage({
+                type: "message",
+                piboSessionId,
+                text: formatRunReminderMessage(notification),
+                source: "service",
+                id: randomUUID(),
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.emitOutput({
+                type: "session_error",
+                piboSessionId,
+                error: message,
+                errorDetails: runtimeSessionErrorDetails(message),
+            });
+        }
+    }
+}