@cognipeer/agent-sdk 0.18.0 → 0.19.0

package/dist/index.d.cts

@@ -2354,9 +2354,12 @@ type TraceEventRecord = {
      * A sub-agent's span (type span, actor.role subagent) is also pending while its
      * run waits; the segment that ends the run records it again under the SAME
      * spanId, finished. Draw one record per spanId: the highest sequence, dropping
-     * earlier pending ones (foldSupersededSpans).
+     * earlier pending and running ones (foldSupersededSpans).
+     * `running`: a sub-agent's span recorded when a segment of its run starts, so a
+     * reader of a trace streamed while the run goes has the group its steps point
+     * at. The record that ends (or pauses) the segment supersedes it.
      */
-    status: "success" | "error" | "skipped" | "retry" | "pending";
+    status: "success" | "error" | "skipped" | "retry" | "pending" | "running";
     durationMs?: number;
     inputTokens?: number;
     outputTokens?: number;
@@ -6099,11 +6102,13 @@ declare function isTraceSessionOpen(session: TraceSessionRuntime | undefined): s
  * segments, and records are append-only: each pause records the run's agent span
  * `pending`, and the segment that ends the run records it again under the SAME
  * `spanId`, finished, with `durationMs` covering the run from its first segment
- * (so the span is drawn over its children from every segment, the wait included). The rule for a
- * reader: for each `spanId` the record with the highest `sequence` wins, and an
- * earlier record of that id is dropped only when it is `pending`. Nothing else is
- * ever dropped, so a repeated id on records that are not `pending` comes back
- * untouched. Order is preserved.
+ * (so the span is drawn over its children from every segment, the wait included).
+ * Each segment also opens with a `running` record of the span, so a trace read
+ * while the run goes (a streamed one) has the group the child's steps point at
+ * before the run ends. The rule for a reader: for each `spanId` the record with
+ * the highest `sequence` wins, and an earlier record of that id is dropped only
+ * when it is `pending` or `running`. Nothing else is ever dropped, so a repeated
+ * id on records that are neither comes back untouched. Order is preserved.
  *
  * The session summary is not rewritten: `eventCounts` keeps counting every record
  * that was written, which is what the file holds.

package/dist/index.d.ts

@@ -2354,9 +2354,12 @@ type TraceEventRecord = {
      * A sub-agent's span (type span, actor.role subagent) is also pending while its
      * run waits; the segment that ends the run records it again under the SAME
      * spanId, finished. Draw one record per spanId: the highest sequence, dropping
-     * earlier pending ones (foldSupersededSpans).
+     * earlier pending and running ones (foldSupersededSpans).
+     * `running`: a sub-agent's span recorded when a segment of its run starts, so a
+     * reader of a trace streamed while the run goes has the group its steps point
+     * at. The record that ends (or pauses) the segment supersedes it.
      */
-    status: "success" | "error" | "skipped" | "retry" | "pending";
+    status: "success" | "error" | "skipped" | "retry" | "pending" | "running";
     durationMs?: number;
     inputTokens?: number;
     outputTokens?: number;
@@ -6099,11 +6102,13 @@ declare function isTraceSessionOpen(session: TraceSessionRuntime | undefined): s
  * segments, and records are append-only: each pause records the run's agent span
  * `pending`, and the segment that ends the run records it again under the SAME
  * `spanId`, finished, with `durationMs` covering the run from its first segment
- * (so the span is drawn over its children from every segment, the wait included). The rule for a
- * reader: for each `spanId` the record with the highest `sequence` wins, and an
- * earlier record of that id is dropped only when it is `pending`. Nothing else is
- * ever dropped, so a repeated id on records that are not `pending` comes back
- * untouched. Order is preserved.
+ * (so the span is drawn over its children from every segment, the wait included).
+ * Each segment also opens with a `running` record of the span, so a trace read
+ * while the run goes (a streamed one) has the group the child's steps point at
+ * before the run ends. The rule for a reader: for each `spanId` the record with
+ * the highest `sequence` wins, and an earlier record of that id is dropped only
+ * when it is `pending` or `running`. Nothing else is ever dropped, so a repeated
+ * id on records that are neither comes back untouched. Order is preserved.
  *
  * The session summary is not rewritten: `eventCounts` keeps counting every record
  * that was written, which is what the file holds.

package/dist/index.mjs

@@ -1248,7 +1248,7 @@ function cacheWriteTokensOf(raw) {
 init_content();
 
 // src/version.ts
-var SDK_VERSION = "0.18.0";
+var SDK_VERSION = "0.19.0";
 
 // src/utils/otlp/content.ts
 init_content();
@@ -1742,7 +1742,7 @@ function sessionToOtlp(file, options) {
   const agentName = file.agent?.name;
   const everyEvent = file.events;
   const exportedEvents = foldSupersededSpans(everyEvent).filter(
-    (event) => options.terminal || !(event.type === "span" && event.status === "pending")
+    (event) => options.terminal || !(event.type === "span" && (event.status === "pending" || event.status === "running"))
   );
   const startMs = parseMs(file.startedAt);
   const nodes = exportedEvents.map((event) => {
@@ -3756,7 +3756,9 @@ function foldSupersededSpans(events) {
     const current = winner.get(id);
     if (current === void 0 || rank(events[i], i) >= rank(events[current], current)) winner.set(id, i);
   }
-  return events.filter((event, i) => !(event.spanId && event.status === "pending" && winner.get(event.spanId) !== i));
+  return events.filter(
+    (event, i) => !(event.spanId && (event.status === "pending" || event.status === "running") && winner.get(event.spanId) !== i)
+  );
 }
 function recordOrDeferTraceEvent(ctx, event, options) {
   const session = ctx?.__traceSession;
@@ -10534,14 +10536,16 @@ function createAgent(opts) {
           const startedAt = Date.now();
           const recordSpan = (status, extra) => {
             if (!traced || !isTraceSessionOpen(parentSession)) return;
+            const running = status === "running";
             recordSubagentSpan(parentSession, {
               spanId: agentSpanId,
-              parentSpanId: context?.traceSpanId ?? parentIterationSpanId,
+              // The delegating tool_call span only exists once the tool returns.
+              parentSpanId: running ? parentIterationSpanId : context?.traceSpanId ?? parentIterationSpanId,
               name: opts.name || "agent",
               status,
-              durationMs: Date.now() - startedAt,
+              durationMs: running ? void 0 : Date.now() - startedAt,
               error: extra.error,
-              info: { name: opts.name || "agent", mode: "asTool", depth: currentDepth + 1, parentToolCallId: context?.toolCallId, status: status === "success" ? "ok" : "error" },
+              info: { name: opts.name || "agent", mode: "asTool", depth: currentDepth + 1, parentToolCallId: context?.toolCallId, status: running ? "running" : status === "success" ? "ok" : "error" },
               task: input,
               result: extra.result
             });
@@ -10561,6 +10565,7 @@ function createAgent(opts) {
             stream: Boolean(parentCtx.__streaming),
             cancellationToken: parentCtx.__cancellationToken ?? parentCtx.__abortSignal
           };
+          recordSpan("running", {});
           let res;
           try {
             res = await instance.invoke({ messages: childMessages, ctx: childCtx }, childConfig);
@@ -12761,14 +12766,16 @@ async function runChild(spec, input, deps, ref, opts) {
   const traceScope = traced ? createSubagentTraceScope(parentSession, { agentSpanId, name: spec.name, spawnId, mode: spec.mode, hitl: opts.allowHITL, iterations: opts.record?.iterations }) : void 0;
   const recordSegment = (status, info) => {
     if (!traced || !isTraceSessionOpen(parentSession)) return;
+    const unfinished = status === "pending" || status === "running";
     recordSubagentSpan(parentSession, {
       spanId: agentSpanId,
-      // The tool_call span only exists once the tool returns; a paused child
-      // has not returned, so its span hangs off the iteration.
-      parentSpanId: status === "pending" ? parentIterationSpanId : opts.parentSpanId ?? parentIterationSpanId,
+      // The tool_call span only exists once the tool returns; a running or
+      // paused child has not returned, so its span hangs off the iteration.
+      parentSpanId: unfinished ? parentIterationSpanId : opts.parentSpanId ?? parentIterationSpanId,
       name: spec.name,
       status,
-      durationMs: elapsedMs(),
+      // A starting segment has no extent yet; a reader draws it over its children.
+      durationMs: status === "running" ? void 0 : elapsedMs(),
       error: info.error,
       info: {
         id: spawnId,
@@ -12779,7 +12786,7 @@ async function runChild(spec, input, deps, ref, opts) {
         parentToolCallId: opts.parentToolCallId,
         status: info.subagentStatus,
         // Only a run that paused has more than one segment to tell about.
-        ...segment > 1 || status === "pending" ? { segments: segment } : {},
+        ...segment > 1 || unfinished ? { segments: segment } : {},
         ...info.note ? { note: info.note } : {},
         ...spec.metadata ? { metadata: spec.metadata } : {}
       },
@@ -12903,6 +12910,7 @@ async function runChild(spec, input, deps, ref, opts) {
   }
   if (traceScope) childInput = { ...childInput, ctx: { ...childInput.ctx || {}, __traceSession: traceScope } };
   const usageBaseline = childInput.usage?.perRequest?.length ?? 0;
+  recordSegment("running", { subagentStatus: "running", input });
   let res;
   try {
     res = await child.invoke(childInput, childConfig);