@pasko70/pibo 1.9.7 → 1.9.9

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

@@ -1,191 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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;
-}