@pasko70/pibo 2.2.4 → 2.3.0

package/dist/core/session-router.js

@@ -3,7 +3,7 @@ import { InitialSessionContext, } from "./profiles.js";
 import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault, selectDefaultPiboProfileName } from "../plugins/builtin.js";
 import { RuntimeRoutedSession as RoutedSession, } from "../agent-runtime/routed-session.js";
 import { runtimeSessionErrorDetails } from "./session-errors.js";
-import { createSubagentToolName } from "../subagents/tool.js";
+import { normalizePiboAgentObservationCursor, normalizePiboAgentObservationLimit, normalizePiboAgentObservationOrder, parsePiboAgentObservationTimestamp, piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationSourceFromEvent, piboAgentObservationText, } from "../subagents/observations.js";
 import { PiboRunRegistry } from "../runs/registry.js";
 import { PiboRunExecutionTimeoutError } from "../runs/lifecycle.js";
 import { PiboRunResourceLimitError } from "../runs/resource-isolation.js";
@@ -15,6 +15,7 @@ import { AgentRuntimeBindingMissingError, AgentRuntimeUnavailableError } from ".
 import { validateAgentRuntimeProfileCapabilities } from "../agent-runtime/profile-validation.js";
 import { getDefaultPiboWorkspace } from "./workspace.js";
 import { loadPiboModelDefaults, selectRequestedFastMode } from "./model-defaults.js";
+import { loadPiboGatewaySettings } from "./gateway-settings.js";
 import { loadPiboUserSettings } from "./user-settings.js";
 import { resolvePiboSessionActiveModel } from "./session-model.js";
 import { isPiboThinkingLevel } from "./thinking.js";
@@ -31,6 +32,7 @@ import { PORTABLE_HISTORY_HANDOFF_METADATA_KEY, PORTABLE_HISTORY_LAST_IMPORT_MET
 const DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
 const DEFAULT_SUBAGENT_MAX_DEPTH = 1;
 const MAX_SUBAGENT_THREAD_KEY_BYTES = 512;
+const MAX_AGENT_OBSERVATIONS = 5_000;
 const DEFAULT_ROUTED_SESSION_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 const DEFAULT_ROUTED_SESSION_DISPOSE_TIMEOUT_MS = 30 * 1000;
 export const LOOP_RUNTIME_RETRY_DEFAULTS = {
@@ -234,6 +236,9 @@ export class PiboSessionRouter {
     runtimeResourceSessions = new Map();
     runtimeAuthFingerprints = new Map();
     activeSubagentChildren = new Map();
+    agentObservations = [];
+    agentObservationEvictedThroughByParent = new Map();
+    nextAgentObservationSequence = 1;
     scheduledRunReminders = new Map();
     runReminderGenerations = new Map();
     runCancellationHandlers = new Map();
@@ -562,32 +567,40 @@ export class PiboSessionRouter {
         }
     }
     descendantSessionIds(parentId) {
-        const output = [];
+        const childrenByParent = new Map();
         for (const session of this.sessionStore.list?.() ?? []) {
-            if (session.parentId !== parentId)
+            if (!session.parentId)
+                continue;
+            const children = childrenByParent.get(session.parentId) ?? [];
+            children.push(session);
+            childrenByParent.set(session.parentId, children);
+        }
+        const output = [];
+        const seen = new Set([parentId]);
+        const stack = [...(childrenByParent.get(parentId) ?? [])].reverse();
+        while (stack.length > 0) {
+            const session = stack.pop();
+            if (seen.has(session.id))
                 continue;
-            output.push(session.id, ...this.descendantSessionIds(session.id));
+            seen.add(session.id);
+            output.push(session.id);
+            const children = childrenByParent.get(session.id);
+            if (children)
+                stack.push(...[...children].reverse());
         }
         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));
-                    await this.invokeRunCancellationHandlers(runs);
-                }
-                const nested = await this.killChildSessions(session.id, options);
-                killed.push(...nested.killed);
-                cancelledRuns.push(...nested.cancelledRuns);
+        for (const id of this.descendantSessionIds(parentId)) {
+            const childSession = this.sessions.get(id);
+            if (childSession)
+                killed.push(await childSession.kill());
+            if (options?.includeRuns) {
+                const runs = this.runRegistry.cancelControllerRuns(id);
+                cancelledRuns.push(...runs.map((run) => run.runId));
+                await this.invokeRunCancellationHandlers(runs);
             }
         }
         return { killed, cancelledRuns };
@@ -934,6 +947,8 @@ export class PiboSessionRouter {
             await this.runtimeResourceService.dispose();
             this.runtimeResourceSessions.clear();
             this.activeSubagentChildren.clear();
+            this.agentObservations.length = 0;
+            this.agentObservationEvictedThroughByParent.clear();
             await this.telemetryWriter?.dispose();
             const lifecycleFailures = [...authDisposals, ...webAppDisposals]
                 .flatMap((result) => result.status === "rejected" ? [result.reason] : []);
@@ -1098,7 +1113,7 @@ export class PiboSessionRouter {
             historyHandoff = { mode: "fresh" };
         }
         const initialFastMode = resolvePiboSessionInitialFastMode(piboSession) ?? selectRequestedFastMode(sessionProfile, modelDefaults) ?? false;
-        const subagentRunner = this.createSubagentRunner(piboSession.id);
+        const agentsController = this.createAgentsController(piboSession.id);
         const runToolController = this.createRunToolController(piboSession.id);
         const codeRuntimeToolController = this.runtimeRegistry.createController(piboSession.id);
         const sessionGeneration = randomUUID();
@@ -1115,7 +1130,7 @@ export class PiboSessionRouter {
             profile: sessionProfile,
             cwd: workspace,
             getActiveMessage: () => session?.getActiveMessage(),
-            subagentRunner,
+            agentsController,
             runToolController,
             runtimeToolController: codeRuntimeToolController,
         });
@@ -1161,7 +1176,7 @@ export class PiboSessionRouter {
                     getActiveMessage: () => session?.getActiveMessage(),
                 },
                 services: {
-                    subagentRunner,
+                    agentsController,
                     runToolController,
                     codeRuntimeToolController,
                     portableTools,
@@ -1582,12 +1597,12 @@ export class PiboSessionRouter {
             id: randomUUID(),
         })));
     }
-    createSubagentRunner(parentPiboSessionId) {
+    createAgentsController(parentPiboSessionId) {
         return {
-            runSubagent: async ({ subagent, message, threadKey, toolCallId, signal }) => {
+            sendMessage: async ({ subagent, message, threadKey, toolCallId, signal }) => {
                 this.assertSubagentDepth(parentPiboSessionId, subagent);
                 const child = this.resolveSubagentSession(parentPiboSessionId, subagent, threadKey);
-                const toolName = createSubagentToolName(subagent.name);
+                const resolvedThreadKey = typeof child.metadata?.threadKey === "string" ? child.metadata.threadKey : "";
                 const event = {
                     type: "message",
                     piboSessionId: child.id,
@@ -1599,22 +1614,154 @@ export class PiboSessionRouter {
                     type: "subagent_session",
                     piboSessionId: parentPiboSessionId,
                     toolCallId,
-                    toolName,
+                    toolName: "pibo_agents_send_message",
                     subagentName: subagent.name,
                     childPiboSessionId: child.id,
-                    threadKey: typeof child.metadata?.threadKey === "string" ? child.metadata.threadKey : undefined,
+                    threadKey: resolvedThreadKey,
                 });
                 const untrack = this.trackActiveSubagent(parentPiboSessionId, child.id);
                 try {
                     const reply = await this.emitMessageAndWaitForReply(event, subagent.timeoutMs ?? DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS, signal);
-                    return { piboSessionId: child.id, eventId: event.id, reply };
+                    return {
+                        agentId: child.id,
+                        name: subagent.name,
+                        profile: child.profile,
+                        threadKey: resolvedThreadKey,
+                        eventId: event.id,
+                        reply,
+                    };
                 }
                 finally {
                     untrack();
                 }
             },
+            listAgents: () => this.listManagedAgents(parentPiboSessionId),
+            observe: (input) => this.observeManagedAgents(parentPiboSessionId, input),
+            killAgent: async (agentId) => await this.killManagedAgent(parentPiboSessionId, agentId),
         };
     }
+    listManagedAgents(parentPiboSessionId) {
+        return this.sessionStore.find({
+            channel: "pibo.subagents",
+            kind: "subagent",
+            parentId: parentPiboSessionId,
+        }).map((session) => {
+            const live = this.sessions.get(session.id)?.getStatus();
+            const killed = session.metadata?.agentStatus === "killed";
+            const running = !killed && Boolean(live && (live.processing || live.streaming || live.queuedMessages > 0));
+            return {
+                agentId: session.id,
+                name: typeof session.metadata?.subagentName === "string" ? session.metadata.subagentName : session.profile,
+                profile: session.profile,
+                ...(typeof session.metadata?.threadKey === "string" ? { threadKey: session.metadata.threadKey } : {}),
+                status: killed ? "killed" : running ? "running" : "idle",
+                createdAt: session.createdAt,
+                updatedAt: session.updatedAt,
+                ...(session.activeModel ? { activeModel: { ...session.activeModel } } : {}),
+            };
+        });
+    }
+    requireManagedAgent(parentPiboSessionId, agentId) {
+        const session = this.sessionStore.get(agentId);
+        if (!session
+            || session.parentId !== parentPiboSessionId
+            || session.channel !== "pibo.subagents"
+            || session.kind !== "subagent") {
+            throw new Error(`Agent "${agentId}" is not owned by Pibo session "${parentPiboSessionId}".`);
+        }
+        return session;
+    }
+    observeManagedAgents(parentPiboSessionId, input) {
+        const order = normalizePiboAgentObservationOrder(input.order);
+        const limit = normalizePiboAgentObservationLimit(input.limit);
+        const afterSequence = normalizePiboAgentObservationCursor(input.afterSequence);
+        const since = parsePiboAgentObservationTimestamp(input.since, "since");
+        const until = parsePiboAgentObservationTimestamp(input.until, "until");
+        if (since !== undefined && until !== undefined && since > until) {
+            throw new Error("Agent observation since must not be after until.");
+        }
+        const agentIds = input.agentIds ? new Set(input.agentIds) : undefined;
+        if (agentIds) {
+            for (const agentId of agentIds)
+                this.requireManagedAgent(parentPiboSessionId, agentId);
+        }
+        const names = input.names ? new Set(input.names) : undefined;
+        const threadKeys = input.threadKeys ? new Set(input.threadKeys) : undefined;
+        const eventTypes = input.eventTypes ? new Set(input.eventTypes) : undefined;
+        const kinds = input.kinds ? new Set(input.kinds) : undefined;
+        const textContains = input.textContains?.toLowerCase();
+        const matches = this.agentObservations.filter((observation) => {
+            if (observation.managingParentId !== parentPiboSessionId)
+                return false;
+            if (agentIds && !agentIds.has(observation.agentId))
+                return false;
+            if (names && !names.has(observation.name))
+                return false;
+            if (threadKeys && (!observation.threadKey || !threadKeys.has(observation.threadKey)))
+                return false;
+            if (eventTypes && !eventTypes.has(observation.eventType))
+                return false;
+            if (kinds && !kinds.has(observation.kind))
+                return false;
+            if (afterSequence !== undefined && observation.sequence <= afterSequence)
+                return false;
+            const createdAt = Date.parse(observation.createdAt);
+            if (since !== undefined && createdAt < since)
+                return false;
+            if (until !== undefined && createdAt > until)
+                return false;
+            if (textContains && !(observation.text ?? "").toLowerCase().includes(textContains))
+                return false;
+            return true;
+        });
+        const cursorPolling = afterSequence !== undefined;
+        const ordered = cursorPolling
+            ? matches.slice(0, limit)
+            : [...matches].sort((left, right) => order === "asc" ? left.sequence - right.sequence : right.sequence - left.sequence).slice(0, limit);
+        if (cursorPolling && order === "desc")
+            ordered.reverse();
+        const selected = ordered.map((observation) => {
+            const { managingParentId: _managingParentId, details, ...visible } = observation;
+            return input.includeDetails === true && details !== undefined ? { ...visible, details } : visible;
+        });
+        const evictedThrough = this.agentObservationEvictedThroughByParent.get(parentPiboSessionId) ?? 0;
+        const retentionTruncated = afterSequence === undefined ? evictedThrough > 0 : afterSequence < evictedThrough;
+        const nextAfterSequence = selected.reduce((maximum, observation) => Math.max(maximum, observation.sequence), afterSequence === undefined ? 0 : Math.max(afterSequence, evictedThrough));
+        return {
+            filters: {
+                ...input,
+                ...(afterSequence !== undefined ? { afterSequence } : {}),
+                order,
+                limit,
+                includeDetails: input.includeDetails === true,
+            },
+            observations: selected,
+            nextAfterSequence,
+            truncated: retentionTruncated || matches.length > selected.length,
+        };
+    }
+    async killManagedAgent(parentPiboSessionId, agentId) {
+        const child = this.requireManagedAgent(parentPiboSessionId, agentId);
+        const ids = [agentId, ...this.descendantSessionIds(agentId)];
+        const idSet = new Set(ids);
+        const cancelledRuns = this.runRegistry.listAll({ includeConsumed: true, includeDetached: true })
+            .filter((run) => idSet.has(run.controllerPiboSessionId) && !isTerminalRunStatus(run.status))
+            .map((run) => run.runId);
+        await Promise.allSettled(ids.flatMap((id) => this.sessions.has(id)
+            ? [this.emit({ type: "execution", piboSessionId: id, action: "abort", id: randomUUID() })]
+            : []));
+        if (child.metadata?.agentStatus !== "killed") {
+            this.sessionStore.update(agentId, {
+                metadata: {
+                    ...(child.metadata ?? {}),
+                    agentStatus: "killed",
+                    killedAt: new Date().toISOString(),
+                },
+            });
+        }
+        await this.disposeSessionSubtree(agentId, `killed by parent ${parentPiboSessionId}`, { cancelRuns: true });
+        return { agentId, killed: ids, cancelledRuns };
+    }
     async invokeRunCancellationHandlers(runs) {
         const results = await Promise.allSettled(runs.map(async (run) => {
             const cancel = this.runCancellationHandlers.get(run.runId);
@@ -1630,7 +1777,10 @@ export class PiboSessionRouter {
     createRunToolController(parentPiboSessionId) {
         return {
             startToolRun: ({ toolName, params, completionPolicy, retryable, maxAttempts, timeoutMs, serviceWarning, resources, execute, cancel }) => {
-                const admission = this.gatewayWorkAdmission.reserve(`yielded run ${toolName}`);
+                const admission = this.gatewayWorkAdmission.reserve(`yielded run ${toolName}`, {
+                    sessionId: parentPiboSessionId,
+                    gatewaySettings: loadPiboGatewaySettings(),
+                });
                 if (resources)
                     resources.admission = admission.admission;
                 const reminderGeneration = this.runReminderGeneration(parentPiboSessionId);
@@ -1731,35 +1881,33 @@ export class PiboSessionRouter {
         const targetProfile = resolvePiboProfileNameFromRegistryOrDefault(this.pluginRegistry, subagent.targetProfile);
         const parent = this.resolvePiboSession(parentPiboSessionId);
         const resolvedThreadKey = resolveSubagentThreadKey(threadKey);
-        const baseMetadata = {
+        const identityMetadata = {
             subagentName: subagent.name,
-            subagentToolName: createSubagentToolName(subagent.name),
             threadKey: resolvedThreadKey,
         };
-        const metadata = withWorkflowSessionKind(baseMetadata, "subagent");
+        const metadata = withWorkflowSessionKind({
+            ...identityMetadata,
+            subagentToolName: "pibo_agents_send_message",
+            agentStatus: "active",
+        }, "subagent");
         const parentChatRoomId = typeof parent.metadata?.chatRoomId === "string" ? parent.metadata.chatRoomId : undefined;
         if (parentChatRoomId)
             metadata.chatRoomId = parentChatRoomId;
         const newSessionMetadata = subagent.thinkingLevel
             ? { ...metadata, initialThinkingLevel: subagent.thinkingLevel }
             : metadata;
-        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);
+        const existing = this.sessionStore.find({
+            channel: "pibo.subagents",
+            kind: "subagent",
+            parentId: parent.id,
+            profile: targetProfile,
+            metadata: identityMetadata,
+        }).find((candidate) => candidate.metadata?.agentStatus !== "killed");
         if (existing) {
             const updatedMetadata = withWorkflowSessionKind({
                 ...(existing.metadata ?? {}),
+                subagentToolName: "pibo_agents_send_message",
+                agentStatus: "active",
                 ...(parentChatRoomId ? { chatRoomId: parentChatRoomId } : {}),
             }, "subagent");
             if (JSON.stringify(updatedMetadata) !== JSON.stringify(existing.metadata ?? {})) {
@@ -1789,8 +1937,40 @@ export class PiboSessionRouter {
         });
         return activeModel ? this.sessionStore.update(childSession.id, { activeModel }) ?? childSession : childSession;
     }
+    recordAgentObservation(event, session) {
+        if (!session || session.kind !== "subagent" || session.channel !== "pibo.subagents" || !session.parentId)
+            return;
+        const name = typeof session.metadata?.subagentName === "string" ? session.metadata.subagentName : session.profile;
+        const source = piboAgentObservationSourceFromEvent(event);
+        const role = piboAgentObservationRole(source);
+        const text = piboAgentObservationText(source);
+        const observation = {
+            managingParentId: session.parentId,
+            sequence: this.nextAgentObservationSequence++,
+            createdAt: new Date().toISOString(),
+            agentId: session.id,
+            name,
+            ...(typeof session.metadata?.threadKey === "string" ? { threadKey: session.metadata.threadKey } : {}),
+            eventType: event.type,
+            kind: piboAgentObservationKind(event.type),
+            ...(role ? { role } : {}),
+            ...(text ? { text } : {}),
+            ...("toolName" in event && typeof event.toolName === "string" ? { toolName: event.toolName } : {}),
+            ...("toolCallId" in event && typeof event.toolCallId === "string" ? { toolCallId: event.toolCallId } : {}),
+            ...(event.type === "tool_execution_finished" ? { isError: event.isError } : event.type === "session_error" ? { isError: true } : {}),
+            details: piboAgentObservationDetails(event),
+        };
+        this.agentObservations.push(observation);
+        if (this.agentObservations.length > MAX_AGENT_OBSERVATIONS) {
+            const evicted = this.agentObservations.splice(0, this.agentObservations.length - MAX_AGENT_OBSERVATIONS);
+            for (const item of evicted) {
+                this.agentObservationEvictedThroughByParent.set(item.managingParentId, Math.max(this.agentObservationEvictedThroughByParent.get(item.managingParentId) ?? 0, item.sequence));
+            }
+        }
+    }
     emitOutput = (event) => {
         const session = this.sessionStore.get(event.piboSessionId);
+        this.recordAgentObservation(event, session);
         this.telemetryRecorder?.recordOutput(event, { session, status: this.sessions.get(event.piboSessionId)?.getStatus() });
         this.signalRegistry.project({ type: "pibo_output", event, session });
         this.pluginRegistry.notifyEvent(event);

package/dist/core/user-settings.js

@@ -5,6 +5,8 @@ import { sanitizeTelemetryRetentionSettings } from "./telemetry-retention-settin
 import { sanitizeTelemetryStaleThresholdSettings } from "./telemetry-staleness.js";
 export const DEFAULT_USER_TIMEZONE = "UTC";
 export const DEFAULT_WEB_ANNOTATIONS_TOGGLE_SHORTCUT = "Alt+Shift+A";
+export const DEFAULT_TRANSCRIPTION_PROVIDER_ID = "openai-chatgpt";
+const LEGACY_OPENAI_TRANSCRIPTION_PROVIDER_ID = "openai";
 export const DEFAULT_PIBO_USER_SETTINGS_PATH = "user-settings.json";
 export function loadPiboUserSettings() {
     return sanitizeUserSettings(readState().settings);
@@ -37,6 +39,23 @@ export function sanitizeShortcut(value) {
     const shortcut = value.replace(/[\u0000-\u001f\u007f]/g, "").trim();
     return shortcut && shortcut.length <= 80 ? shortcut : undefined;
 }
+export function sanitizeTranscriptionProviderId(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const providerId = value.trim();
+    return /^[a-z0-9][a-z0-9._-]{0,79}$/i.test(providerId) ? providerId : undefined;
+}
+export function sanitizeTranscriptionSettings(value) {
+    const raw = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    const providerId = sanitizeTranscriptionProviderId(raw.providerId);
+    return {
+        providerId: providerId === LEGACY_OPENAI_TRANSCRIPTION_PROVIDER_ID
+            ? DEFAULT_TRANSCRIPTION_PROVIDER_ID
+            : providerId ?? DEFAULT_TRANSCRIPTION_PROVIDER_ID,
+    };
+}
 export function sanitizeTimezone(value) {
     if (typeof value !== "string")
         return undefined;
@@ -58,6 +77,7 @@ function sanitizeUserSettings(value) {
     return {
         timezone: sanitizeTimezone(raw.timezone) ?? DEFAULT_USER_TIMEZONE,
         shortcuts: sanitizeShortcutSettings(raw.shortcuts),
+        transcription: sanitizeTranscriptionSettings(raw.transcription),
         telemetryStaleThresholds: sanitizeTelemetryStaleThresholdSettings(raw.telemetryStaleThresholds),
         telemetryRetention: sanitizeTelemetryRetentionSettings(raw.telemetryRetention),
     };

package/dist/data/ingest-service.js

@@ -322,14 +322,26 @@ function attributesForOutputEvent(event) {
         return { inlineText: event.text, source: event.source, queuedMessages: event.queuedMessages };
     if (event.type === "message_steered")
         return { inlineText: event.text, source: event.source, activeEventId: event.activeEventId };
+    if (event.type === "message_started")
+        return { inlineText: event.text, source: event.source };
+    if (event.type === "message_finished")
+        return { source: event.source };
     if (event.type === "assistant_message" || event.type === "assistant_delta")
         return { assistantIndex: event.assistantIndex, contentIndex: event.contentIndex };
+    if (event.type === "assistant_usage")
+        return {
+            inputTokens: event.inputTokens,
+            outputTokens: event.outputTokens,
+            cacheReadTokens: event.cacheReadTokens,
+            cacheWriteTokens: event.cacheWriteTokens,
+            totalTokens: event.totalTokens,
+        };
     if (event.type === "thinking_started" || event.type === "thinking_delta" || event.type === "thinking_finished")
         return { thinkingIndex: event.thinkingIndex, contentIndex: event.contentIndex };
     if (event.type === "tool_call")
-        return { toolCallId: event.toolCallId, toolName: event.toolName, argsComplete: event.argsComplete };
+        return { toolCallId: event.toolCallId, toolName: event.toolName, argsComplete: event.argsComplete, intent: event.intent };
     if (event.type === "tool_execution_started" || event.type === "tool_execution_updated" || event.type === "tool_execution_finished")
-        return { toolCallId: event.toolCallId, toolName: event.toolName, isError: "isError" in event ? event.isError : undefined };
+        return { toolCallId: event.toolCallId, toolName: event.toolName, isError: "isError" in event ? event.isError : undefined, intent: event.intent };
     if (event.type === "subagent_session")
         return { toolCallId: event.toolCallId, toolName: event.toolName, subagentName: event.subagentName, childPiboSessionId: event.childPiboSessionId, threadKey: event.threadKey };
     if (event.type === "execution_result")