@dxos/plugin-assistant 0.10.0 → 0.11.1

package/dist/lib/neutral/execution-graph/index.mjs

@@ -1,977 +0,0 @@
-import "../chunk-J5LGTIGS.mjs";
-
-// src/execution-graph/execution-graph.ts
-import * as Array from "effect/Array";
-import * as Either from "effect/Either";
-import { pipe } from "effect/Function";
-import * as Option from "effect/Option";
-import * as Pipeable from "effect/Pipeable";
-import * as Schema from "effect/Schema";
-import * as Struct from "effect/Struct";
-import { AgentRequestBegin as AgentRequestBegin2, AgentRequestEnd as AgentRequestEnd2, CompleteBlock } from "@dxos/assistant";
-import { Process, Trace as Trace2 } from "@dxos/compute";
-import { Annotation } from "@dxos/echo";
-import { AGENT_PROCESS_KEY } from "@dxos/functions-runtime";
-import { EID as EID2 } from "@dxos/keys";
-import { LogLevel, log } from "@dxos/log";
-
-// src/execution-graph/span-tree.ts
-import { AgentRequestBegin, AgentRequestEnd } from "@dxos/assistant";
-import { Trace } from "@dxos/compute";
-import { EID } from "@dxos/keys";
-var ROOT_SPAN_ID = "<main>";
-var BEGIN_EVENT_TYPES = /* @__PURE__ */ new Set([
-  Trace.OperationStart.key,
-  AgentRequestBegin.key
-]);
-var END_EVENT_TYPES = /* @__PURE__ */ new Set([
-  Trace.OperationEnd.key,
-  AgentRequestEnd.key
-]);
-var isSpanBeginEvent = (event) => BEGIN_EVENT_TYPES.has(event.type);
-var isSpanEndEvent = (event) => END_EVENT_TYPES.has(event.type);
-var computeMeta = (rawMeta) => ({
-  pid: rawMeta.pid,
-  parentPid: rawMeta.parentPid,
-  processName: rawMeta.processName,
-  conversationId: rawMeta.conversation ? EID.getEntityId(EID.parse(rawMeta.conversation.uri)) : void 0,
-  triggerId: rawMeta.trigger ? EID.getEntityId(EID.parse(rawMeta.trigger.uri)) : void 0,
-  toolCallId: rawMeta.toolCallId,
-  runtimeName: rawMeta.runtimeName
-});
-var makeMutableSpan = (id, meta) => ({
-  id,
-  meta,
-  events: [],
-  children: [],
-  firstTimestamp: Number.POSITIVE_INFINITY
-});
-var freezeSpan = (span) => ({
-  id: span.id,
-  meta: span.meta,
-  events: span.events,
-  children: span.children.map(freezeSpan)
-});
-var buildSpanTree = (messages, options = {}) => {
-  const allEvents = messages.flatMap((message) => Trace.flatten(message));
-  allEvents.sort((a, b) => a.timestamp - b.timestamp);
-  const events = applyEventLimit(allEvents, options.eventLimit);
-  const root = makeMutableSpan(ROOT_SPAN_ID, {});
-  const openSpans = /* @__PURE__ */ new Map();
-  const lastSpanByPid = /* @__PURE__ */ new Map();
-  let spanCounter = 0;
-  const allocSpanId = (pid) => {
-    const id = `${pid}#${spanCounter}`;
-    spanCounter += 1;
-    return id;
-  };
-  const noteTimestamp = (span, timestamp) => {
-    if (timestamp < span.firstTimestamp) {
-      span.firstTimestamp = timestamp;
-    }
-  };
-  for (const event of events) {
-    const pid = event.meta.pid;
-    if (!pid) {
-      root.events.push(event);
-      noteTimestamp(root, event.timestamp);
-      continue;
-    }
-    if (BEGIN_EVENT_TYPES.has(event.type)) {
-      const parentPid = event.meta.parentPid;
-      const parent = parentPid && (openSpans.get(parentPid) ?? lastSpanByPid.get(parentPid)) || root;
-      const span = makeMutableSpan(allocSpanId(pid), computeMeta(event.meta));
-      span.events.push(event);
-      noteTimestamp(span, event.timestamp);
-      parent.children.push(span);
-      openSpans.set(pid, span);
-      lastSpanByPid.set(pid, span);
-      continue;
-    }
-    if (END_EVENT_TYPES.has(event.type)) {
-      const span = openSpans.get(pid);
-      if (span) {
-        span.events.push(event);
-        noteTimestamp(span, event.timestamp);
-        openSpans.delete(pid);
-      } else {
-        root.events.push(event);
-        noteTimestamp(root, event.timestamp);
-      }
-      continue;
-    }
-    const open = openSpans.get(pid);
-    if (open) {
-      open.events.push(event);
-      noteTimestamp(open, event.timestamp);
-    } else {
-      root.events.push(event);
-      noteTimestamp(root, event.timestamp);
-    }
-  }
-  const sortChildren = (span) => {
-    span.children.sort((a, b) => a.firstTimestamp - b.firstTimestamp);
-    for (const child of span.children) {
-      sortChildren(child);
-    }
-  };
-  sortChildren(root);
-  return freezeSpan(root);
-};
-var applyEventLimit = (events, eventLimit) => {
-  if (eventLimit === void 0) {
-    return [
-      ...events
-    ];
-  }
-  let nonBoundaryCount = 0;
-  for (const event of events) {
-    if (!isBoundary(event)) {
-      nonBoundaryCount += 1;
-    }
-  }
-  if (nonBoundaryCount <= eventLimit) {
-    return [
-      ...events
-    ];
-  }
-  const dropCount = nonBoundaryCount - eventLimit;
-  let dropped = 0;
-  const result = [];
-  for (const event of events) {
-    if (!isBoundary(event) && dropped < dropCount) {
-      dropped += 1;
-      continue;
-    }
-    result.push(event);
-  }
-  return result;
-};
-var isBoundary = (event) => BEGIN_EVENT_TYPES.has(event.type) || END_EVENT_TYPES.has(event.type);
-var walkSpanTree = (root, visit, depth = 0) => {
-  visit(root, depth);
-  for (const child of root.children) {
-    walkSpanTree(child, visit, depth + 1);
-  }
-};
-var flattenSpanTree = (root) => {
-  const result = [];
-  walkSpanTree(root, (span) => result.push(span));
-  return result;
-};
-
-// src/execution-graph/execution-graph.ts
-var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/execution-graph/execution-graph.ts";
-var MAIN_BRANCH = "main";
-var SHIMMER_EFFECT_TAG = "effect:shimmer";
-var ICONS = {
-  agentRequestBegin: {
-    icon: "ph--atom--regular",
-    level: LogLevel.VERBOSE
-  },
-  agentRequestEndSuccess: {
-    icon: "ph--atom--regular",
-    level: LogLevel.INFO
-  },
-  agentRequestEndError: {
-    icon: "ph--atom--regular",
-    level: LogLevel.ERROR
-  },
-  agentRequestEndInterrupted: {
-    icon: "ph--atom--regular",
-    level: LogLevel.WARN
-  },
-  userMessage: {
-    icon: "ph--user--regular",
-    level: LogLevel.VERBOSE
-  },
-  statusMessage: {
-    icon: "ph--info--regular",
-    level: LogLevel.VERBOSE
-  },
-  operationStart: {
-    icon: "ph--function--regular",
-    level: LogLevel.VERBOSE
-  },
-  operationEndSuccess: {
-    icon: "ph--function--regular",
-    level: LogLevel.INFO
-  },
-  operationEndError: {
-    icon: "ph--function--regular",
-    level: LogLevel.ERROR
-  },
-  toolCall: {
-    icon: "ph--wrench--regular",
-    level: LogLevel.VERBOSE
-  },
-  toolResultSuccess: {
-    icon: "ph--wrench--regular",
-    level: LogLevel.INFO
-  },
-  toolResultError: {
-    icon: "ph--wrench--regular",
-    level: LogLevel.ERROR
-  },
-  agentRequestRunning: {
-    icon: "ph--spinner-gap--regular",
-    level: LogLevel.VERBOSE
-  },
-  processRunning: {
-    icon: "ph--spinner-gap--regular",
-    level: LogLevel.VERBOSE
-  }
-};
-var buildExecutionGraph = ({ traceMessages, activeProcesses = [], collapseCompletedSpans = false, eventLimit = 500 }) => {
-  const spanTree = buildSpanTree(traceMessages, {
-    eventLimit
-  });
-  const toolCallContext = buildToolCallContext(traceMessages);
-  const built = spanTreeToCommits(spanTree, activeProcesses, toolCallContext, collapseCompletedSpans);
-  log("trace execution graph", {
-    traceMessages: traceMessages.length,
-    commits: built.commits.length,
-    branches: built.branches.length,
-    activeProcesses: activeProcesses.length
-  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 86, S: void 0 });
-  return {
-    ...built,
-    spanTree
-  };
-};
-var buildToolCallContext = (messages) => {
-  const callById = /* @__PURE__ */ new Map();
-  const resultByCallId = /* @__PURE__ */ new Map();
-  for (const message of messages) {
-    for (const event of message.events) {
-      if (event.type !== CompleteBlock.key) {
-        continue;
-      }
-      const data = event.data;
-      const block = data?.block;
-      if (!block) {
-        continue;
-      }
-      if (block._tag === "toolCall") {
-        callById.set(block.toolCallId, block);
-      } else if (block._tag === "toolResult") {
-        resultByCallId.set(block.toolCallId, block);
-      }
-    }
-  }
-  return {
-    callById,
-    resultByCallId
-  };
-};
-var parseAgentRequestEnd = (data) => {
-  const validated = Schema.validateEither(AgentRequestEnd2.schema)(data);
-  if (Either.isRight(validated)) {
-    return validated.right;
-  }
-  if (data != null && typeof data === "object" && Object.keys(data).length === 0) {
-    return {
-      status: "success"
-    };
-  }
-  log("invalid trace event", {
-    type: AgentRequestEnd2.key
-  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 135, S: void 0 });
-  return void 0;
-};
-var presentAgentRequestEnd = (data) => {
-  switch (data.status) {
-    case "error":
-      return {
-        icon: ICONS.agentRequestEndError.icon,
-        level: ICONS.agentRequestEndError.level,
-        message: data.error ? trimText(`Agent request failed: ${data.error}`) : "Agent request failed"
-      };
-    case "interrupted":
-      return {
-        icon: ICONS.agentRequestEndInterrupted.icon,
-        level: ICONS.agentRequestEndInterrupted.level,
-        message: "Agent request interrupted"
-      };
-    default:
-      return {
-        icon: ICONS.agentRequestEndSuccess.icon,
-        level: ICONS.agentRequestEndSuccess.level,
-        message: "Agent completed request"
-      };
-  }
-};
-var presentEvent = (event, toolCallContext) => {
-  if (Trace2.isOfType(AgentRequestBegin2, event)) {
-    if (Either.isLeft(Schema.validateEither(AgentRequestBegin2.schema)(event.data))) {
-      log("invalid trace event", {
-        type: event.type
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 165, S: void 0 });
-      return void 0;
-    }
-    return {
-      icon: ICONS.agentRequestBegin.icon,
-      level: ICONS.agentRequestBegin.level,
-      message: "Agent processing request..."
-    };
-  }
-  if (Trace2.isOfType(AgentRequestEnd2, event)) {
-    const endData = parseAgentRequestEnd(event.data);
-    if (!endData) {
-      return void 0;
-    }
-    return presentAgentRequestEnd(endData);
-  }
-  if (Trace2.isOfType(CompleteBlock, event)) {
-    if (Either.isLeft(Schema.validateEither(CompleteBlock.schema)(event.data))) {
-      log("invalid trace event", {
-        type: event.type
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 185, S: void 0 });
-      return void 0;
-    }
-    switch (event.data.block._tag) {
-      case "text":
-        return event.data.role === "user" ? {
-          icon: ICONS.userMessage.icon,
-          level: ICONS.userMessage.level,
-          message: trimText(event.data.block.text)
-        } : void 0;
-      case "status":
-        return {
-          icon: ICONS.statusMessage.icon,
-          level: ICONS.statusMessage.level,
-          message: trimText(event.data.block.statusText)
-        };
-      case "toolCall": {
-        if (event.data.block.operationKey) {
-          return void 0;
-        }
-        if (toolCallContext.resultByCallId.has(event.data.block.toolCallId)) {
-          return void 0;
-        }
-        return {
-          icon: ICONS.toolCall.icon,
-          level: ICONS.toolCall.level,
-          message: event.data.block.name,
-          idSuffix: `toolCall:${event.data.block.toolCallId}`
-        };
-      }
-      case "toolResult": {
-        const call = toolCallContext.callById.get(event.data.block.toolCallId);
-        if (call?.operationKey) {
-          return void 0;
-        }
-        const success = event.data.block.error === void 0;
-        const name = call?.name ?? event.data.block.name;
-        return {
-          icon: success ? ICONS.toolResultSuccess.icon : ICONS.toolResultError.icon,
-          level: success ? ICONS.toolResultSuccess.level : ICONS.toolResultError.level,
-          message: `${name}${!success ? " - Error" : ""}`,
-          idSuffix: `toolResult:${event.data.block.toolCallId}`
-        };
-      }
-      default:
-        return void 0;
-    }
-  }
-  if (Trace2.isOfType(Trace2.OperationStart, event)) {
-    if (Either.isLeft(Schema.validateEither(Trace2.OperationStart.schema)(event.data))) {
-      log("invalid trace event", {
-        type: event.type
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 247, S: void 0 });
-      return void 0;
-    }
-    return {
-      icon: event.data.icon ?? ICONS.operationStart.icon,
-      level: ICONS.operationStart.level,
-      message: event.data.name ?? event.data.key,
-      idSuffix: `${event.data.key}:start`
-    };
-  }
-  if (Trace2.isOfType(Trace2.OperationEnd, event)) {
-    if (Either.isLeft(Schema.validateEither(Trace2.OperationEnd.schema)(event.data))) {
-      log("invalid trace event", {
-        type: event.type
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 261, S: void 0 });
-      return void 0;
-    }
-    const success = event.data.outcome === "success";
-    return {
-      icon: event.data.icon ?? (success ? ICONS.operationEndSuccess.icon : ICONS.operationEndError.icon),
-      level: success ? ICONS.operationEndSuccess.level : ICONS.operationEndError.level,
-      message: `${event.data.name ?? event.data.key}${!success ? " - Error" : ""}`,
-      idSuffix: `${event.data.key}:end`
-    };
-  }
-  return void 0;
-};
-var collectProcessActivityLines = (messages, rootPid, options = {}) => {
-  const { conversationId, eventLimit = 50 } = options;
-  const descendantPids = collectDescendantPids(messages, rootPid);
-  const filtered = messages.filter((message) => {
-    const pid = message.meta.pid;
-    if (!pid || !descendantPids.has(pid)) {
-      return false;
-    }
-    const metaConvId = message.meta.conversation ? EID2.getEntityId(EID2.parse(message.meta.conversation.uri)) : void 0;
-    if (conversationId && metaConvId !== void 0 && metaConvId !== conversationId) {
-      return false;
-    }
-    return true;
-  });
-  const events = filtered.flatMap((message) => Trace2.flatten(message)).sort((left, right) => left.timestamp - right.timestamp).slice(-eventLimit);
-  const toolCallContext = buildToolCallContext(filtered);
-  const lines = [];
-  for (const event of events) {
-    const presentation = presentEvent(event, toolCallContext);
-    if (presentation) {
-      lines.push(presentation.message);
-    }
-  }
-  return lines;
-};
-var deriveInFlightActivityLine = (messages, rootPid, options = {}) => {
-  const { conversationId, eventLimit = 50 } = options;
-  const descendantPids = collectDescendantPids(messages, rootPid);
-  const filtered = messages.filter((message) => {
-    const pid = message.meta.pid;
-    if (!pid || !descendantPids.has(pid)) {
-      return false;
-    }
-    const metaConvId = message.meta.conversation ? EID2.getEntityId(EID2.parse(message.meta.conversation.uri)) : void 0;
-    if (conversationId && metaConvId !== void 0 && metaConvId !== conversationId) {
-      return false;
-    }
-    return true;
-  });
-  const events = filtered.flatMap((message) => Trace2.flatten(message)).sort((left, right) => left.timestamp - right.timestamp).slice(-eventLimit);
-  const openOperations = /* @__PURE__ */ new Map();
-  let agentRequestOpen = false;
-  let lastLine;
-  for (const event of events) {
-    const pid = event.meta.pid ?? rootPid;
-    if (Trace2.isOfType(Trace2.OperationStart, event)) {
-      const key = `${pid}:${event.data.key}`;
-      const name = event.data.name ?? event.data.key;
-      openOperations.set(key, {
-        name,
-        timestamp: event.timestamp
-      });
-      lastLine = `${name}...`;
-      continue;
-    }
-    if (Trace2.isOfType(Trace2.OperationEnd, event)) {
-      openOperations.delete(`${pid}:${event.data.key}`);
-      continue;
-    }
-    if (Trace2.isOfType(AgentRequestBegin2, event)) {
-      agentRequestOpen = true;
-      lastLine = "Generating...";
-      continue;
-    }
-    if (Trace2.isOfType(AgentRequestEnd2, event)) {
-      agentRequestOpen = false;
-    }
-  }
-  if (agentRequestOpen) {
-    return "Generating...";
-  }
-  const latestOperation = [
-    ...openOperations.values()
-  ].sort((left, right) => right.timestamp - left.timestamp)[0];
-  if (latestOperation) {
-    return `${latestOperation.name}...`;
-  }
-  return lastLine;
-};
-var collectDescendantPids = (messages, rootPid) => {
-  const pids = /* @__PURE__ */ new Set([
-    rootPid
-  ]);
-  let expanded = true;
-  while (expanded) {
-    expanded = false;
-    for (const message of messages) {
-      const pid = message.meta.pid;
-      const parentPid = message.meta.parentPid;
-      if (pid && parentPid && pids.has(parentPid) && !pids.has(pid)) {
-        pids.add(pid);
-        expanded = true;
-      }
-    }
-  }
-  return pids;
-};
-var isPendingToolCallEvent = (event, toolCallContext) => {
-  if (!Trace2.isOfType(CompleteBlock, event)) {
-    return false;
-  }
-  if (event.data.block._tag !== "toolCall") {
-    return false;
-  }
-  return !toolCallContext.resultByCallId.has(event.data.block.toolCallId);
-};
-var shouldShimmerInProgressCommit = (event, toolCallContext) => isPendingToolCallEvent(event, toolCallContext);
-var isCompletedSpan = (span) => {
-  if (span.id === ROOT_SPAN_ID) {
-    return false;
-  }
-  const lastEvent = span.events[span.events.length - 1];
-  return lastEvent !== void 0 && isSpanEndEvent(lastEvent);
-};
-var isCollapsibleSpan = (span, parent, collapseCompletedSpans) => {
-  if (span.id === ROOT_SPAN_ID) {
-    return false;
-  }
-  if (parent === null) {
-    return false;
-  }
-  if (span.events.length === 2 && span.children.length === 0) {
-    const firstEvent = span.events[0];
-    const lastEvent = span.events[span.events.length - 1];
-    if (isSpanBeginEvent(firstEvent) && isSpanEndEvent(lastEvent)) {
-      return true;
-    }
-  }
-  if (collapseCompletedSpans && isCompletedSpan(span)) {
-    return true;
-  }
-  return false;
-};
-var spanTreeToCommits = (root, activeProcesses, toolCallContext, collapseCompletedSpans) => {
-  const builder = new GraphBuilder();
-  const details = {};
-  builder.addBranch(MAIN_BRANCH);
-  const parentBySpan = /* @__PURE__ */ new Map();
-  parentBySpan.set(root, null);
-  const indexParents = (span) => {
-    for (const child of span.children) {
-      parentBySpan.set(child, span);
-      indexParents(child);
-    }
-  };
-  indexParents(root);
-  const findParentSpan = (span) => parentBySpan.get(span) ?? null;
-  const collapsedSpanIds = /* @__PURE__ */ new Set();
-  walkSpanTree(root, (span) => {
-    if (isCollapsibleSpan(span, findParentSpan(span), collapseCompletedSpans)) {
-      collapsedSpanIds.add(span.id);
-    }
-  });
-  const isUnderCollapsedAncestor = (span) => {
-    let ancestor = findParentSpan(span);
-    while (ancestor) {
-      if (collapsedSpanIds.has(ancestor.id)) {
-        return true;
-      }
-      ancestor = findParentSpan(ancestor);
-    }
-    return false;
-  };
-  const branchOf = (span) => {
-    if (!span || span.id === ROOT_SPAN_ID) {
-      return MAIN_BRANCH;
-    }
-    return span.meta.pid ?? span.id;
-  };
-  const beginCommitIdBySpan = /* @__PURE__ */ new Map();
-  const lastInSpanContext = (span) => {
-    if (!span || span.id === ROOT_SPAN_ID) {
-      return CommitSelector.branch(MAIN_BRANCH).pipe(CommitSelector.compose(CommitSelector.last()));
-    }
-    const ownBranch = branchOf(span);
-    const beginId = beginCommitIdBySpan.get(span.id);
-    return CommitSelector.firstOf(CommitSelector.branch(ownBranch).pipe(CommitSelector.compose(CommitSelector.last())), beginId ? CommitSelector.id(beginId) : CommitSelector.filter(() => false), lastInSpanContext(findParentSpan(span)));
-  };
-  const lastCommitIdBySpan = /* @__PURE__ */ new Map();
-  let globalIndex = 0;
-  const insertedRunningPids = /* @__PURE__ */ new Set();
-  const activeProcessByPid = new Map(activeProcesses.map((process) => [
-    process.pid,
-    process
-  ]));
-  const emitRunningIndicator = (pid) => {
-    if (insertedRunningPids.has(pid)) {
-      return;
-    }
-    const process = activeProcessByPid.get(pid);
-    if (!process) {
-      return;
-    }
-    if (process.key === AGENT_PROCESS_KEY && Option.isSome(Annotation.getDictionary(process.params.annotations, Process.TargetAnnotation)) && (process.state === Process.State.RUNNING || process.state === Process.State.HYBERNATING)) {
-      builder.addCommit({
-        id: `running:${process.pid}`,
-        branch: process.pid,
-        parents: builder.computeParents(CommitSelector.branch(process.pid).pipe(CommitSelector.compose(CommitSelector.last()))),
-        icon: ICONS.agentRequestRunning.icon,
-        level: ICONS.agentRequestRunning.level,
-        message: "Generating...",
-        timestamp: /* @__PURE__ */ new Date(),
-        tags: [
-          SHIMMER_EFFECT_TAG
-        ]
-      });
-      insertedRunningPids.add(pid);
-    } else if (process.state === Process.State.RUNNING && builder.hasBranch(process.pid)) {
-      builder.addCommit({
-        id: `running:${process.pid}`,
-        branch: process.pid,
-        parents: builder.computeParents(CommitSelector.branch(process.pid).pipe(CommitSelector.compose(CommitSelector.last()))),
-        icon: ICONS.processRunning.icon,
-        level: ICONS.processRunning.level,
-        message: "Running...",
-        timestamp: /* @__PURE__ */ new Date(),
-        tags: [
-          SHIMMER_EFFECT_TAG
-        ]
-      });
-      insertedRunningPids.add(pid);
-    }
-  };
-  const emitEventCommit = (span, event, eventIndex) => {
-    const presentation = presentEvent(event, toolCallContext);
-    if (!presentation) {
-      return;
-    }
-    const isBeginEvent = isSpanBeginEvent(event);
-    const isEndEvent = isSpanEndEvent(event);
-    const parentSpan = findParentSpan(span);
-    const collapsible = isCollapsibleSpan(span, parentSpan, collapseCompletedSpans);
-    if (isUnderCollapsedAncestor(span)) {
-      return;
-    }
-    if (collapsible && !isEndEvent) {
-      return;
-    }
-    const parentBranch = branchOf(parentSpan);
-    const ownBranch = branchOf(span);
-    const ownPid = span.meta.pid;
-    const parentPid = parentSpan?.meta.pid;
-    const spanHasMiddle = span.events.some((spanEvent) => !isSpanBeginEvent(spanEvent) && !isSpanEndEvent(spanEvent));
-    const isProcessBoundary = ownPid != null && parentPid != null && ownPid !== parentPid && spanHasMiddle;
-    let branch;
-    let parents;
-    if (span.id === ROOT_SPAN_ID) {
-      branch = MAIN_BRANCH;
-      parents = builder.computeParents(lastInSpanContext(null));
-    } else if (collapsible) {
-      branch = parentBranch;
-      parents = builder.computeParents(lastInSpanContext(parentSpan));
-    } else if (isBeginEvent) {
-      branch = isProcessBoundary ? ownBranch : parentBranch;
-      parents = builder.computeParents(lastInSpanContext(parentSpan));
-    } else if (isEndEvent) {
-      branch = isProcessBoundary ? MAIN_BRANCH : parentBranch;
-      parents = builder.computeParents(CommitSelector.unionAll(CommitSelector.branch(branch).pipe(CommitSelector.compose(CommitSelector.last())), CommitSelector.branch(ownBranch).pipe(CommitSelector.compose(CommitSelector.last()))));
-    } else {
-      branch = ownBranch;
-      parents = builder.computeParents(lastInSpanContext(span));
-    }
-    const commitIndex = globalIndex++;
-    const commitId = formatCommitId(span, commitIndex, presentation.idSuffix);
-    const shimmer = shouldShimmerInProgressCommit(event, toolCallContext);
-    const commit = {
-      id: commitId,
-      branch,
-      parents,
-      timestamp: new Date(event.timestamp),
-      icon: presentation.icon,
-      level: presentation.level,
-      message: presentation.message,
-      ...shimmer && {
-        tags: [
-          SHIMMER_EFFECT_TAG
-        ]
-      }
-    };
-    builder.addCommit(commit);
-    details[commitId] = event;
-    lastCommitIdBySpan.set(span.id, commitId);
-    if (isBeginEvent && !collapsible && span.id !== ROOT_SPAN_ID) {
-      beginCommitIdBySpan.set(span.id, commitId);
-    }
-  };
-  const finishSpan = (span) => {
-    const pid = span.meta.pid;
-    if (pid) {
-      emitRunningIndicator(Process.ID.make(pid));
-    }
-    if (span.id === ROOT_SPAN_ID || isCompletedSpan(span)) {
-      return;
-    }
-    if (pid && insertedRunningPids.has(pid)) {
-      return;
-    }
-    const lastCommitId = lastCommitIdBySpan.get(span.id);
-    if (lastCommitId) {
-      builder.addTag(lastCommitId, SHIMMER_EFFECT_TAG);
-    }
-  };
-  const emitSpanCommits = (span) => {
-    for (let eventIndex = 0; eventIndex < span.events.length; eventIndex += 1) {
-      const event = span.events[eventIndex];
-      if (isSpanBeginEvent(event)) {
-        emitEventCommit(span, event, eventIndex);
-      }
-    }
-    for (const child of span.children) {
-      emitSpanCommits(child);
-    }
-    for (let eventIndex = 0; eventIndex < span.events.length; eventIndex += 1) {
-      const event = span.events[eventIndex];
-      if (!isSpanBeginEvent(event)) {
-        emitEventCommit(span, event, eventIndex);
-      }
-    }
-    finishSpan(span);
-  };
-  emitSpanCommits(root);
-  for (const process of activeProcesses) {
-    emitRunningIndicator(process.pid);
-  }
-  const { commits, branches } = builder.build();
-  return {
-    commits,
-    branches,
-    details
-  };
-};
-var formatCommitId = (span, globalIndex, suffix) => {
-  const base = `${span.id}:${globalIndex}`;
-  return suffix ? `${base}:${suffix}` : base;
-};
-var trimText = (text) => text.slice(0, 100).trim().split("\n")[0];
-var CommitSelector = {
-  make: (select) => ({
-    select,
-    pipe(...args) {
-      return Pipeable.pipeArguments(this, args);
-    }
-  }),
-  identity: () => CommitSelector.make((commits) => commits),
-  /**
-  * Selects commits that match the given predicate.
-  */
-  filter: (predicate) => CommitSelector.make((commits) => commits.filter(predicate)),
-  /**
-  * Selects commits by id.
-  */
-  id: (id) => CommitSelector.filter((commit) => commit.id === id),
-  /**
-  * Selects commits by tag.
-  */
-  tag: (tag) => CommitSelector.filter((commit) => tag && commit.tags?.includes(tag)),
-  /**
-  * Selects commits by if any of the given tags are present.
-  */
-  anyTags: (tags) => CommitSelector.filter((commit) => tags.some((tag) => tag && commit.tags?.includes(tag))),
-  /**
-  * Selects commits by branch.
-  */
-  branch: (branch) => CommitSelector.filter((commit) => branch && commit.branch === branch),
-  /**
-  * Chains two selectors together, applying the second selector to the result of the first.
-  *
-  * Example:
-  *
-  * ```
-  * CommitSelector.tag('tag').pipe(CommitSelector.compose(CommitSelector.branch('main')));
-  * ```
-  */
-  compose: (next) => (prev) => CommitSelector.make((commits) => next.select(prev.select(commits))),
-  /**
-  * If `prev` selector matches no commits, return `next` selector, otherwise return `prev` selector.
-  * Same as `CommitSelector.firstOf(prev, next)`.
-  *
-  * Example:
-  *
-  * ```
-  * CommitSelector.tag('tag').pipe(CommitSelector.orElse(CommitSelector.branch('main')));
-  * ```
-  */
-  orElse: (next) => (prev) => CommitSelector.make((commits) => {
-    const selected = prev.select(commits);
-    if (selected.length > 0) {
-      return selected;
-    }
-    return next.select(commits);
-  }),
-  /**
-  * Selects commits that match either of the given selectors.
-  */
-  andAlso: (next) => (prev) => CommitSelector.unionAll(prev, next),
-  /**
-  * Selects the first n commits.
-  */
-  first: (n = 1) => CommitSelector.make((commits) => commits.slice(0, n)),
-  /**
-  * Selects the last n commits (reverses the order of the commits).
-  */
-  last: (n = 1) => CommitSelector.make((commits) => commits.toReversed().slice(0, n)),
-  /**
-  * Selects commits that do not match the given selector.
-  */
-  not: (selector) => CommitSelector.make((commits) => {
-    const selected = selector.select(commits);
-    return commits.filter((commit) => !selected.includes(commit));
-  }),
-  /**
-  * Selects commits that match any of the given selectors.
-  */
-  unionAll: (...selectors) => CommitSelector.make((commits) => {
-    return Array.dedupeWith(selectors.flatMap((selector) => selector.select(commits)), (a, b) => a.id === b.id);
-  }),
-  /**
-  * Selects commits that match all of the given selectors.
-  */
-  intersectAll: (...selectors) => CommitSelector.make((commits) => {
-    const selected = selectors.map((selector) => selector.select(commits));
-    if (selected.length === 0) {
-      return [];
-    }
-    return selected[0].filter((commit) => selected.every((selected2) => selected2.some((c) => c.id === commit.id)));
-  }),
-  /**
-  * Returns the result of the first selector that matches any commits.
-  */
-  firstOf: (...selectors) => CommitSelector.make((commits) => {
-    for (const selector of selectors) {
-      const selected = selector.select(commits);
-      if (selected.length > 0) {
-        return selected;
-      }
-    }
-    return [];
-  })
-};
-var GraphBuilder = class {
-  #commits = [];
-  #branches = /* @__PURE__ */ new Set();
-  findCommits(selector) {
-    return selector.select(this.#commits);
-  }
-  hasBranch(branch) {
-    return this.#branches.has(branch);
-  }
-  addCommit(commit) {
-    this.addBranch(commit.branch);
-    this.#commits.push(commit);
-  }
-  addTag(commitId, tag) {
-    const index = this.#commits.findIndex((commit2) => commit2.id === commitId);
-    if (index < 0) {
-      return;
-    }
-    const commit = this.#commits[index];
-    if (commit.tags?.includes(tag)) {
-      return;
-    }
-    this.#commits[index] = {
-      ...commit,
-      tags: [
-        ...commit.tags ?? [],
-        tag
-      ]
-    };
-  }
-  /**
-  * Computes parents — picks first matching commit's id.
-  */
-  computeParents(selector) {
-    return Array.dedupe(selector.select(this.#commits).map((commit) => commit.id));
-  }
-  addBranch(branch) {
-    this.#branches.add(branch);
-  }
-  /**
-  * Removes duplicate commits and dangling parents.
-  */
-  doctor() {
-    this.#commits = pipe(this.#commits, Array.dedupeWith((a, b) => a.id === b.id), Array.map(Struct.evolve({
-      parents: (parents) => parents ? Array.filter(parents, (id) => this.#commits.some((commit) => commit.id === id)) : void 0
-    })));
-  }
-  build() {
-    this.doctor();
-    return {
-      commits: this.#commits,
-      branches: [
-        ...this.#branches
-      ]
-    };
-  }
-};
-
-// src/execution-graph/pending-block-status.ts
-import { PartialBlock } from "@dxos/assistant";
-import { Trace as Trace3 } from "@dxos/compute";
-var estimateTokenCount = (text) => Math.max(1, Math.ceil(new TextEncoder().encode(text).length / 4));
-var formatOperationInputStatus = (data) => {
-  const name = data.name ?? data.key;
-  const bytes = new TextEncoder().encode(JSON.stringify(data.input)).length;
-  return `Calling ${name} (${bytes} bytes)...`;
-};
-var ROUTINE_ULID_STATUS = /^Running [0-9A-HJKMNP-TV-Z]{26}$/i;
-var formatPendingBlockStatus = (block) => {
-  if (!block.pending) {
-    return void 0;
-  }
-  if (block._tag === "text") {
-    return `Generating ${estimateTokenCount(block.text)} tokens....`;
-  }
-  if (block._tag === "toolCall") {
-    const bytes = new TextEncoder().encode(block.input).length;
-    const name = block.operationName ?? block.name;
-    return `Calling ${name} (${bytes} bytes)...`;
-  }
-  return void 0;
-};
-var pendingStatusFromEphemeralMessage = (message) => {
-  for (const event of message.events) {
-    if (Trace3.isOfType(PartialBlock, event)) {
-      const status = formatPendingBlockStatus(event.data.block);
-      if (status) {
-        return status;
-      }
-      continue;
-    }
-    if (Trace3.isOfType(Trace3.OperationInput, event)) {
-      return formatOperationInputStatus(event.data);
-    }
-    if (Trace3.isOfType(Trace3.StatusUpdate, event)) {
-      if (ROUTINE_ULID_STATUS.test(event.data.message.trim())) {
-        continue;
-      }
-      return event.data.message;
-    }
-  }
-  return void 0;
-};
-var resolveEphemeralStatusUpdate = (message) => {
-  const line = pendingStatusFromEphemeralMessage(message);
-  if (line) {
-    return {
-      line
-    };
-  }
-  return "unchanged";
-};
-export {
-  BEGIN_EVENT_TYPES,
-  CommitSelector,
-  END_EVENT_TYPES,
-  ROOT_SPAN_ID,
-  buildExecutionGraph,
-  buildSpanTree,
-  collectProcessActivityLines,
-  deriveInFlightActivityLine,
-  estimateTokenCount,
-  flattenSpanTree,
-  formatPendingBlockStatus,
-  isSpanBeginEvent,
-  isSpanEndEvent,
-  pendingStatusFromEphemeralMessage,
-  resolveEphemeralStatusUpdate,
-  walkSpanTree
-};
-//# sourceMappingURL=index.mjs.map