@pasko70/pibo 1.9.9 → 1.9.10

package/dist/shared/trace-live-reducer.js

@@ -0,0 +1,191 @@
+export function applyTraceLiveEvents(input) {
+    let events = input.currentEvents;
+    let mutableEvents;
+    let seenIdentities;
+    const ensureSeenIdentities = () => {
+        seenIdentities ??= new Set(events.map(eventIdentityKey));
+        return seenIdentities;
+    };
+    const appendStoredEvent = (event) => {
+        mutableEvents ??= events.slice();
+        mutableEvents.push(event);
+        events = mutableEvents;
+    };
+    for (const streamEvent of input.streamEvents) {
+        const stored = storedEventFromStreamEvent(streamEvent, input.piboSessionId, input.nextSequence, input.now ?? (() => new Date().toISOString()));
+        if (!stored)
+            continue;
+        if (isFinalReplacementEvent(stored)) {
+            events = replaceLiveDeltasWithFinalEvent(events, stored);
+            mutableEvents = events;
+            seenIdentities = undefined;
+            continue;
+        }
+        const identity = eventIdentityKey(stored);
+        const seen = ensureSeenIdentities();
+        if (seen.has(identity))
+            continue;
+        seen.add(identity);
+        appendStoredEvent(stored);
+    }
+    return events;
+}
+function isFinalReplacementEvent(event) {
+    return event.type === "assistant_message"
+        || event.type === "thinking_finished"
+        || event.type === "tool_execution_finished";
+}
+function replaceLiveDeltasWithFinalEvent(events, event) {
+    if (event.type === "assistant_message") {
+        return [...dropMatching(events, event, "assistant_delta"), event];
+    }
+    if (event.type === "thinking_finished") {
+        return [...dropMatching(events, event, "thinking_delta"), event];
+    }
+    if (event.type === "tool_execution_finished") {
+        return [...dropMatching(events, event, "tool_execution_updated"), event];
+    }
+    return events;
+}
+function storedEventFromStreamEvent(event, piboSessionId, nextSequence, now) {
+    if (event.type === "RAW_EVENT" && isRecord(event.event) && typeof event.event.type === "string") {
+        const payload = event.event;
+        return makeStored(event, piboSessionId, event.event.type, payload, nextSequence, now);
+    }
+    if (event.type === "TEXT_MESSAGE_CONTENT" && typeof event.delta === "string") {
+        const payload = {
+            type: "assistant_delta",
+            piboSessionId,
+            eventId: typeof event.runId === "string" ? event.runId : undefined,
+            ...partIndexFromMessageId(typeof event.messageId === "string" ? event.messageId : undefined, "assistant"),
+            text: event.delta,
+        };
+        return makeStored(event, piboSessionId, "assistant_delta", payload, nextSequence, now);
+    }
+    if (event.type === "REASONING_MESSAGE_CONTENT" && typeof event.delta === "string") {
+        const payload = {
+            type: "thinking_delta",
+            piboSessionId,
+            eventId: typeof event.runId === "string" ? event.runId : undefined,
+            ...partIndexFromMessageId(typeof event.messageId === "string" ? event.messageId : undefined, "thinking"),
+            text: event.delta,
+        };
+        return makeStored(event, piboSessionId, "thinking_delta", payload, nextSequence, now);
+    }
+    if (event.type === "TOOL_CALL_START" && typeof event.toolCallId === "string" && typeof event.toolName === "string") {
+        const payload = {
+            type: "tool_execution_started",
+            piboSessionId,
+            eventId: typeof event.runId === "string" ? event.runId : undefined,
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            args: event.args,
+        };
+        return makeStored(event, piboSessionId, "tool_execution_started", payload, nextSequence, now);
+    }
+    if (event.type === "TOOL_CALL_ARGS" && typeof event.toolCallId === "string" && typeof event.toolName === "string") {
+        const eventId = typeof event.runId === "string" ? event.runId : undefined;
+        const sourceEventType = event.sourceEventType === "tool_execution_updated" ? "tool_execution_updated" : "tool_call";
+        const payload = sourceEventType === "tool_execution_updated"
+            ? {
+                type: "tool_execution_updated",
+                piboSessionId,
+                eventId,
+                toolCallId: event.toolCallId,
+                toolName: event.toolName,
+                args: event.args,
+                partialResult: event.partialResult,
+            }
+            : {
+                type: "tool_call",
+                piboSessionId,
+                eventId,
+                toolCallId: event.toolCallId,
+                toolName: event.toolName,
+                args: event.args,
+                argsComplete: Boolean(event.argsComplete),
+            };
+        return makeStored(event, piboSessionId, sourceEventType, payload, nextSequence, now);
+    }
+    if (event.type === "TOOL_CALL_RESULT" && typeof event.toolCallId === "string" && typeof event.toolName === "string") {
+        const payload = {
+            type: "tool_execution_finished",
+            piboSessionId,
+            eventId: typeof event.runId === "string" ? event.runId : undefined,
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            result: event.result,
+            isError: Boolean(event.isError),
+        };
+        return makeStored(event, piboSessionId, "tool_execution_finished", payload, nextSequence, now);
+    }
+    if (event.type === "RUN_ERROR" && typeof event.message === "string") {
+        const payload = {
+            type: "session_error",
+            piboSessionId,
+            eventId: typeof event.runId === "string" ? event.runId : undefined,
+            error: event.message,
+            errorDetails: event.errorDetails,
+        };
+        return makeStored(event, piboSessionId, "session_error", payload, nextSequence, now);
+    }
+    return undefined;
+}
+function makeStored(streamEvent, piboSessionId, type, payload, nextSequence, now) {
+    const streamFrame = typeof streamEvent.streamFrameId === "string" ? streamEvent.streamFrameId : undefined;
+    const streamFrameIndex = typeof streamEvent.streamFrameIndex === "number" ? streamEvent.streamFrameIndex : undefined;
+    const liveReplayId = typeof streamEvent.liveReplayId === "number" && Number.isFinite(streamEvent.liveReplayId) ? streamEvent.liveReplayId : undefined;
+    const sequence = nextSequence();
+    return {
+        id: typeof streamEvent.streamId === "number"
+            ? `stream:${streamEvent.streamId}:${streamFrameIndex ?? "raw"}:${type}`
+            : liveReplayId !== undefined
+                ? `live-replay:${liveReplayId}:${type}`
+                : streamFrame
+                    ? `stream:${streamFrame}:${type}`
+                    : `live:${sequence}:${type}`,
+        piboSessionId,
+        eventSequence: sequence,
+        streamId: typeof streamEvent.streamId === "number" ? streamEvent.streamId : undefined,
+        streamFrameIndex,
+        eventId: typeof payload.eventId === "string" ? payload.eventId : undefined,
+        type,
+        createdAt: now(),
+        payload,
+    };
+}
+function dropMatching(events, finalEvent, dropType) {
+    const finalKey = eventGroupKey(finalEvent);
+    return events.filter((event) => event.type !== dropType || eventGroupKey(event) !== finalKey);
+}
+function eventIdentityKey(event) {
+    if (event.streamId !== undefined) {
+        return event.streamFrameIndex !== undefined
+            ? `stream:${event.streamId}:${event.streamFrameIndex}:${event.type}`
+            : `stream:${event.streamId}:${event.id}:${event.type}`;
+    }
+    return `${event.id}:${event.type}`;
+}
+function eventGroupKey(event) {
+    const payload = isRecord(event.payload) ? event.payload : {};
+    const piboSessionId = typeof payload.piboSessionId === "string" ? payload.piboSessionId : event.piboSessionId ?? "";
+    const eventId = typeof payload.eventId === "string" ? payload.eventId : event.eventId ?? "";
+    if (typeof payload.toolCallId === "string")
+        return `${piboSessionId}:${eventId}:tool:${payload.toolCallId}`;
+    const assistantIndex = typeof payload.assistantIndex === "number" ? payload.assistantIndex : undefined;
+    const thinkingIndex = typeof payload.thinkingIndex === "number" ? payload.thinkingIndex : undefined;
+    const contentIndex = typeof payload.contentIndex === "number" ? payload.contentIndex : 0;
+    return `${piboSessionId}:${eventId}:${assistantIndex ?? thinkingIndex ?? contentIndex}`;
+}
+function partIndexFromMessageId(messageId, kind) {
+    const match = messageId?.match(new RegExp(`:${kind}:(\\d+)$`));
+    if (!match)
+        return {};
+    const value = Number(match[1]);
+    if (!Number.isInteger(value))
+        return {};
+    return kind === "assistant" ? { assistantIndex: value } : { thinkingIndex: value };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/shared/trace-nodes.js

@@ -0,0 +1,88 @@
+import { compareTraceOrder } from "./trace-order.js";
+export function sortTraceNodes(nodes) {
+    let hasSortedChildren = false;
+    const nodesWithSortedChildren = nodes.map((node) => {
+        if (!node.children.length)
+            return node;
+        hasSortedChildren = true;
+        return { ...node, children: sortTraceNodes(node.children) };
+    });
+    if (areTraceNodesSorted(nodesWithSortedChildren))
+        return hasSortedChildren ? nodesWithSortedChildren : [...nodes];
+    return [...nodesWithSortedChildren].sort(compareTraceNodes);
+}
+function areTraceNodesSorted(nodes) {
+    for (let index = 1; index < nodes.length; index += 1) {
+        if (compareTraceNodes(nodes[index - 1], nodes[index]) > 0)
+            return false;
+    }
+    return true;
+}
+export function compareTraceNodes(left, right) {
+    const bySameTurnPhase = compareSameTurnPhase(left, right);
+    if (bySameTurnPhase !== 0)
+        return bySameTurnPhase;
+    const byStartTime = compareOptionalIsoTime(left.startedAt, right.startedAt);
+    if (byStartTime !== 0)
+        return byStartTime;
+    const byOrder = compareTraceOrder(left.orderKey, right.orderKey);
+    if (byOrder !== 0)
+        return byOrder;
+    return left.id.localeCompare(right.id);
+}
+function compareSameTurnPhase(left, right) {
+    if (!left.eventId || left.eventId !== right.eventId)
+        return 0;
+    const leftPhase = left.orderKey?.phaseRank;
+    const rightPhase = right.orderKey?.phaseRank;
+    if (leftPhase === undefined || rightPhase === undefined)
+        return 0;
+    return leftPhase - rightPhase;
+}
+function compareOptionalIsoTime(left, right) {
+    if (!left && !right)
+        return 0;
+    if (!left)
+        return 1;
+    if (!right)
+        return -1;
+    return left.localeCompare(right);
+}
+export function flattenTraceNodes(nodes) {
+    const flattened = [];
+    const stack = [...nodes].reverse();
+    while (stack.length) {
+        const node = stack.pop();
+        if (!node)
+            continue;
+        flattened.push(node);
+        for (let index = node.children.length - 1; index >= 0; index -= 1) {
+            stack.push(node.children[index]);
+        }
+    }
+    return flattened;
+}
+export function nestTraceNodes(nodes) {
+    const byId = new Map();
+    for (const node of nodes) {
+        byId.set(node.id, { ...node, children: [...node.children] });
+    }
+    const nestedChildIds = new Set();
+    for (const node of byId.values()) {
+        if (!node.parentId)
+            continue;
+        const parent = byId.get(node.parentId);
+        if (!parent)
+            continue;
+        parent.children.push(node);
+        nestedChildIds.add(node.id);
+    }
+    const roots = [...byId.values()].filter((node) => !nestedChildIds.has(node.id));
+    return sortTraceNodes(roots);
+}
+export function mapTraceNodesById(nodes) {
+    const byId = new Map();
+    for (const node of flattenTraceNodes(nodes))
+        byId.set(node.id, node);
+    return byId;
+}

package/dist/shared/trace-order.js

@@ -0,0 +1,84 @@
+export const TRACE_SOURCE_RANK = {
+    transcript: 0,
+    "event-log": 1,
+    live: 2,
+};
+export const TRACE_PHASE_RANK = {
+    "user.message": 0,
+    "execution.command": 1,
+    "execution.compaction": 1,
+    "agent.turn": 2,
+    "model.reasoning": 3,
+    "tool.call": 4,
+    "agent.delegation": 4,
+    "agent.async": 5,
+    "tool.result": 6,
+    "yielded.run": 7,
+    "assistant.message": 8,
+    error: 9,
+};
+export function transcriptTraceOrder(transcriptIndex, contentPartIndex, type) {
+    return {
+        sourceRank: TRACE_SOURCE_RANK.transcript,
+        turnSeq: transcriptIndex,
+        transcriptIndex,
+        contentPartIndex,
+        phaseRank: TRACE_PHASE_RANK[type],
+    };
+}
+export function eventTraceOrder(eventSequence, type) {
+    return {
+        sourceRank: TRACE_SOURCE_RANK["event-log"],
+        turnSeq: eventSequence ?? Number.MAX_SAFE_INTEGER,
+        eventSequence,
+        phaseRank: TRACE_PHASE_RANK[type],
+    };
+}
+export function liveTraceOrder(streamId, streamFrameIndex, type) {
+    const streamOrder = streamId ?? Number.MAX_SAFE_INTEGER;
+    const frameIndex = streamFrameIndex ?? Number.MAX_SAFE_INTEGER;
+    return {
+        sourceRank: TRACE_SOURCE_RANK.live,
+        turnSeq: streamOrder,
+        streamId: streamOrder,
+        streamFrameIndex: frameIndex,
+        phaseRank: TRACE_PHASE_RANK[type],
+    };
+}
+export function parseTraceStreamFrameId(value) {
+    const [stream, frame] = value.split(":");
+    if (stream === undefined || frame === undefined)
+        return undefined;
+    const streamId = Number(stream);
+    const frameIndex = Number(frame);
+    if (!Number.isInteger(streamId) || streamId < 0)
+        return undefined;
+    if (!Number.isInteger(frameIndex) || frameIndex < 0)
+        return undefined;
+    return { streamId, frameIndex };
+}
+export function childTraceOrder(parent, type) {
+    if (!parent)
+        return undefined;
+    return {
+        ...parent,
+        contentPartIndex: (parent.contentPartIndex ?? 0) + 0.1,
+        phaseRank: TRACE_PHASE_RANK[type],
+    };
+}
+export function compareTraceOrder(left, right) {
+    if (!left && !right)
+        return 0;
+    if (!left)
+        return 1;
+    if (!right)
+        return -1;
+    return (left.sourceRank - right.sourceRank ||
+        left.turnSeq - right.turnSeq ||
+        (left.transcriptIndex ?? Number.MAX_SAFE_INTEGER) - (right.transcriptIndex ?? Number.MAX_SAFE_INTEGER) ||
+        (left.eventSequence ?? Number.MAX_SAFE_INTEGER) - (right.eventSequence ?? Number.MAX_SAFE_INTEGER) ||
+        (left.streamId ?? Number.MAX_SAFE_INTEGER) - (right.streamId ?? Number.MAX_SAFE_INTEGER) ||
+        (left.streamFrameIndex ?? Number.MAX_SAFE_INTEGER) - (right.streamFrameIndex ?? Number.MAX_SAFE_INTEGER) ||
+        (left.contentPartIndex ?? 0) - (right.contentPartIndex ?? 0) ||
+        left.phaseRank - right.phaseRank);
+}

package/dist/shared/trace-page-merge.js

@@ -0,0 +1,40 @@
+import { flattenTraceNodes, nestTraceNodes } from "./trace-nodes.js";
+export function mergeOlderTracePage(current, older) {
+    if (current.piboSessionId !== older.piboSessionId)
+        return current;
+    const seenRawEvents = new Set();
+    const rawEvents = [...older.rawEvents, ...current.rawEvents].filter((event) => {
+        const key = event.id || `${event.eventSequence ?? ""}:${event.type}:${event.createdAt}`;
+        if (seenRawEvents.has(key))
+            return false;
+        seenRawEvents.add(key);
+        return true;
+    });
+    return {
+        ...current,
+        version: current.version,
+        nodes: mergeTraceNodes(older.nodes, current.nodes),
+        rawEvents,
+        beforeCursor: older.beforeCursor ?? current.beforeCursor,
+        firstEventSequence: older.firstEventSequence ?? current.firstEventSequence,
+        nextBeforeSequence: older.nextBeforeSequence,
+        nextBeforeCursor: older.nextBeforeCursor,
+        hasOlderEvents: older.hasOlderEvents,
+        eventLimit: (current.eventLimit ?? 0) + (older.eventLimit ?? older.pageSize ?? 0),
+    };
+}
+function mergeTraceNodes(olderNodes, currentNodes) {
+    const byId = new Map();
+    for (const node of flattenTraceNodes([...olderNodes])) {
+        byId.set(node.id, { ...node, children: [] });
+    }
+    for (const node of flattenTraceNodes([...currentNodes])) {
+        const existing = byId.get(node.id);
+        byId.set(node.id, {
+            ...existing,
+            ...node,
+            children: [],
+        });
+    }
+    return nestTraceNodes([...byId.values()]);
+}

package/dist/shared/trace-patch-nodes.js

@@ -0,0 +1,83 @@
+import { sortTraceNodes } from "./trace-nodes.js";
+export function nestMutableCopiedTraceNodes(nodes) {
+    const byId = new Map();
+    for (const node of nodes)
+        byId.set(node.id, node);
+    const roots = [];
+    for (const node of nodes) {
+        if (!node.parentId) {
+            roots.push(node);
+            continue;
+        }
+        const parent = byId.get(node.parentId);
+        if (parent)
+            parent.children.push(node);
+        else
+            roots.push(node);
+    }
+    return sortTraceNodes(roots);
+}
+export function shareUnchangedTraceNodes(previousById, nextNodes, contentDeltaChangedNodeIds) {
+    return nextNodes.map((node) => shareUnchangedTraceNode(previousById, node, contentDeltaChangedNodeIds));
+}
+function shareUnchangedTraceNode(previousById, nextNode, contentDeltaChangedNodeIds) {
+    const previousNode = previousById.get(nextNode.id);
+    if (nextNode.children.length === 0) {
+        const childrenUnchanged = previousNode !== undefined && previousNode.children.length === 0;
+        if (previousNode && childrenUnchanged) {
+            if (contentDeltaChangedNodeIds && !contentDeltaChangedNodeIds.has(nextNode.id))
+                return previousNode;
+            if (traceNodeShallowEqual(previousNode, nextNode))
+                return previousNode;
+        }
+        return childrenUnchanged ? { ...nextNode, children: previousNode.children } : { ...nextNode, children: [] };
+    }
+    const sharedChildren = nextNode.children.map((child) => shareUnchangedTraceNode(previousById, child, contentDeltaChangedNodeIds));
+    const childrenUnchanged = previousNode !== undefined &&
+        previousNode.children.length === sharedChildren.length &&
+        previousNode.children.every((child, index) => child === sharedChildren[index]);
+    if (previousNode && childrenUnchanged) {
+        if (contentDeltaChangedNodeIds && !contentDeltaChangedNodeIds.has(nextNode.id))
+            return previousNode;
+        if (traceNodeShallowEqual(previousNode, nextNode))
+            return previousNode;
+    }
+    return childrenUnchanged ? { ...nextNode, children: previousNode?.children ?? sharedChildren } : { ...nextNode, children: sharedChildren };
+}
+function traceNodeShallowEqual(left, right) {
+    return (left.id === right.id &&
+        left.parentId === right.parentId &&
+        left.entryId === right.entryId &&
+        left.piboSessionId === right.piboSessionId &&
+        left.eventId === right.eventId &&
+        left.toolCallId === right.toolCallId &&
+        left.runId === right.runId &&
+        left.type === right.type &&
+        left.title === right.title &&
+        left.status === right.status &&
+        left.startedAt === right.startedAt &&
+        left.completedAt === right.completedAt &&
+        left.durationMs === right.durationMs &&
+        left.summary === right.summary &&
+        left.input === right.input &&
+        left.output === right.output &&
+        left.error === right.error &&
+        left.linkedPiboSessionId === right.linkedPiboSessionId &&
+        left.source === right.source &&
+        left.stableKey === right.stableKey &&
+        traceOrderKeyEqual(left.orderKey, right.orderKey));
+}
+function traceOrderKeyEqual(left, right) {
+    if (left === right)
+        return true;
+    if (!left || !right)
+        return false;
+    return (left.sourceRank === right.sourceRank &&
+        left.turnSeq === right.turnSeq &&
+        left.transcriptIndex === right.transcriptIndex &&
+        left.contentPartIndex === right.contentPartIndex &&
+        left.eventSequence === right.eventSequence &&
+        left.streamId === right.streamId &&
+        left.streamFrameIndex === right.streamFrameIndex &&
+        left.phaseRank === right.phaseRank);
+}

package/dist/shared/trace-run-notifications.js

@@ -0,0 +1,69 @@
+export function parseRunNotificationText(text) {
+    // Legacy history support only: live yielded-run state is projected from Session Signals.
+    const trimmed = (text ?? "").trim();
+    const start = "<pibo_run_notification>";
+    const end = "</pibo_run_notification>";
+    if (!trimmed.startsWith(start) || !trimmed.endsWith(end))
+        return undefined;
+    const jsonText = trimmed.slice(start.length, trimmed.length - end.length).trim();
+    try {
+        const parsed = JSON.parse(jsonText);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createRunNotificationNode(input) {
+    const runs = runNotificationRuns(input.notification);
+    const singleRun = runs.length === 1 ? runs[0] : undefined;
+    const failedCount = countRunGroup(input.notification.failed);
+    const runningCount = countRunGroup(input.notification.running);
+    return {
+        id: input.id,
+        entryId: input.entryId,
+        piboSessionId: input.piboSessionId,
+        eventId: input.eventId,
+        runId: typeof singleRun?.runId === "string" ? singleRun.runId : undefined,
+        type: "yielded.run",
+        title: "Run Notification",
+        status: failedCount > 0 ? "error" : runningCount > 0 ? "running" : "done",
+        startedAt: input.startedAt,
+        summary: runNotificationSummary(input.notification),
+        output: input.notification,
+        source: input.source,
+        stableKey: input.stableKey ?? input.id,
+        orderKey: input.orderKey,
+        children: [],
+    };
+}
+function runNotificationRuns(notification) {
+    return [
+        ...runGroup(notification.completed),
+        ...runGroup(notification.failed),
+        ...runGroup(notification.cancelled),
+        ...runGroup(notification.running),
+    ];
+}
+function runGroup(value) {
+    return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function countRunGroup(value) {
+    return Array.isArray(value) ? value.length : 0;
+}
+function runNotificationSummary(notification) {
+    const parts = [
+        [countRunGroup(notification.completed), "completed"],
+        [countRunGroup(notification.failed), "failed"],
+        [countRunGroup(notification.cancelled), "cancelled"],
+        [countRunGroup(notification.running), "running"],
+    ]
+        .filter(([count]) => Number(count) > 0)
+        .map(([count, label]) => `${count} ${label}`);
+    return parts.length ? parts.join(", ") : "No yielded run updates";
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/shared/trace-subagent-links.js

@@ -0,0 +1,46 @@
+export function mapTraceChildSessionsByParent(sessions) {
+    const result = new Map();
+    for (const session of sessions) {
+        if (!session.parentId)
+            continue;
+        const children = result.get(session.parentId) ?? [];
+        children.push(session);
+        result.set(session.parentId, children);
+    }
+    return result;
+}
+export function mapTraceSubagentSessionLinks(events) {
+    const result = new Map();
+    for (const storedEvent of events) {
+        const event = storedEvent.payload;
+        if (event.type !== "subagent_session" || !event.toolCallId)
+            continue;
+        result.set(event.toolCallId, event.childPiboSessionId);
+    }
+    return result;
+}
+export function findLikelyTraceChildSession(piboSessionId, toolName, event, childByParent) {
+    if (!isSubagentToolName(toolName))
+        return undefined;
+    const candidates = childByParent
+        .get(piboSessionId)
+        ?.filter((session) => session.metadata?.subagentToolName === toolName) ?? [];
+    const threadKey = toolEventThreadKey(event);
+    if (threadKey) {
+        return candidates.find((session) => session.metadata?.threadKey === threadKey)?.id;
+    }
+    return candidates.length === 1 ? candidates[0].id : undefined;
+}
+export function isSubagentToolName(name) {
+    return name.startsWith("pibo_subagent_");
+}
+export function subagentNameFromToolName(toolName) {
+    return toolName.slice("pibo_subagent_".length);
+}
+function toolEventThreadKey(event) {
+    const args = "args" in event && event.args && typeof event.args === "object" && !Array.isArray(event.args)
+        ? event.args
+        : undefined;
+    const threadKey = args && "threadKey" in args ? args.threadKey : undefined;
+    return typeof threadKey === "string" && threadKey.trim() ? threadKey.trim() : undefined;
+}