@inixiative/agent-session 0.6.4 → 0.6.6

package/src/codex-session.ts

@@ -944,6 +944,8 @@ export class CodexAppServerSession implements HarnessSession {
   private _approvals = new Map<string, AbortController>();
   /** The owned turn's in-progress fileChange items' changes, by item id, for their approvals. */
   private _fileChanges = new Map<string, readonly CodexFileChange[]>();
+  /** Child threads this session's turns spawned (collab `spawnAgent`), to the spawning item's id. */
+  private _children = new Map<string, string>();
   private _items = new Map<
     string,
     {
@@ -1266,6 +1268,8 @@ export class CodexAppServerSession implements HarnessSession {
           thread.turns.some((value) => !this._turn(value)))
       )
         this._refuse('configuration-missing-or-incompatible');
+      // Sub-agents belong to the thread that spawned them.
+      if (this._externalSessionId !== id) this._children.clear();
       this._externalSessionId = id;
       this._nativeSessionId =
         typeof thread?.sessionId === 'string' && thread.sessionId ? thread.sessionId : undefined;
@@ -1430,6 +1434,9 @@ export class CodexAppServerSession implements HarnessSession {
       },
     ];
     const a = this._inflight?.evidence;
+    const spawnedBy = threadId ? this._children.get(threadId) : undefined;
+    if (threadId && spawnedBy)
+      return this._childEvents(method, threadId, spawnedBy, turn, item, unowned);
     if (!threadId || threadId !== this._externalSessionId) return unowned('foreign-session');
     if (!a || this._appAdmission !== a.admissionId) return unowned('no-admission');
     if (turnId && this._seenTerminals.has(turnId))
@@ -1519,6 +1526,50 @@ export class CodexAppServerSession implements HarnessSession {
         else this._fileChanges.delete(itemId);
         return unowned('unrecognized-event');
       }
+      if (item.type === 'collabAgentToolCall') {
+        // A sub-agent this turn spawned (its thread is named once known, on start or completion),
+        // or closed. Other collab calls (send input, wait) are diagnostics.
+        const receivers = Array.isArray(item.receiverThreadIds)
+          ? item.receiverThreadIds.filter((id): id is string => typeof id === 'string' && !!id)
+          : [];
+        const prompt = typeof item.prompt === 'string' && item.prompt ? item.prompt : undefined;
+        if (item.tool === 'spawnAgent') {
+          const fresh = receivers.filter((child) => !this._children.has(child));
+          if (!fresh.length) return status();
+          return fresh.map((child): SessionEvent => {
+            this._children.set(child, itemId);
+            return {
+              ...identity,
+              kind: 'subagent',
+              timestamp: Date.now(),
+              subagent: {
+                phase: 'started',
+                taskId: child,
+                toolUseId: itemId,
+                agentType: 'spawnAgent',
+                depth: 1,
+                backgrounded: true,
+                ...(prompt ? { prompt } : {}),
+              },
+            };
+          });
+        }
+        if (item.tool === 'closeAgent' && method === 'item/completed') {
+          const closed = receivers.filter((child) => this._children.has(child));
+          if (!closed.length) return status();
+          return closed.map((child): SessionEvent => {
+            const toolUseId = this._children.get(child)!;
+            this._children.delete(child);
+            return {
+              ...identity,
+              kind: 'subagent',
+              timestamp: Date.now(),
+              subagent: { phase: 'ended', taskId: child, toolUseId, status: 'closed' },
+            };
+          });
+        }
+        return status();
+      }
       if (item.type === 'agentMessage') {
         if (method !== 'item/completed') return status();
         if (this._items.get(itemId)?.completed) return unowned('after-terminal');
@@ -1638,6 +1689,43 @@ export class CodexAppServerSession implements HarnessSession {
     }
     return method === 'turn/started' ? status() : unowned('unrecognized-event');
   }
+
+  /**
+   * A spawned sub-agent's thread, outside any admission of this session: its final messages as
+   * text and its turns' ends as lifecycle, tagged with the spawning item. Anything else stays a
+   * diagnostic, tagged the same way.
+   */
+  private _childEvents(
+    method: string,
+    threadId: string,
+    spawnedBy: string,
+    turn: { id: string; status: string; error?: unknown } | undefined,
+    item: Record<string, unknown> | undefined,
+    unowned: (reason: NonNullable<SessionEvent['unattributedReason']>) => SessionEvent[],
+  ): SessionEvent[] {
+    const tag = { parentToolUseId: spawnedBy, unattributedReason: 'subagent' as const };
+    const base = { threadId, correlation: 'unknown' as const, timestamp: Date.now(), ...tag };
+    if (
+      method === 'item/completed' &&
+      item?.type === 'agentMessage' &&
+      typeof item.text === 'string'
+    )
+      return [{ ...base, kind: 'text', text: item.text }];
+    if (method === 'turn/completed' && turn && turn.status !== 'inProgress')
+      return [
+        {
+          ...base,
+          kind: 'subagent',
+          subagent: {
+            phase: 'updated',
+            taskId: threadId,
+            toolUseId: spawnedBy,
+            status: turn.status,
+          },
+        },
+      ];
+    return unowned('subagent').map((event) => ({ ...event, ...tag }));
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/harness-session.ts

@@ -92,7 +92,38 @@ export type SessionEventKind =
   | 'usage'
   | 'rate_limit'
   | 'result'
-  | 'error';
+  | 'error'
+  | 'subagent';
+
+/**
+ * A subagent's lifecycle as the native runtime reports it (kind `subagent`). Claude Code: its
+ * `system` task frames for an Agent/Task call. Codex: a collab `spawnAgent` item and its child thread.
+ */
+export interface SubagentLifecycle {
+  readonly phase: 'started' | 'progress' | 'updated' | 'ended';
+  /** The native id of the subagent run (Claude task id, Codex child thread id). */
+  readonly taskId: string;
+  /** The tool call that spawned it, in its parent's stream. */
+  readonly toolUseId?: string;
+  /** The task that spawned it, when a subagent spawned it (Claude). */
+  readonly parentTaskId?: string;
+  readonly agentType?: string;
+  readonly description?: string;
+  /** 1 for a child of the main thread. */
+  readonly depth?: number;
+  readonly backgrounded?: boolean;
+  /** The native status at the end (completed, stopped, failed, killed). */
+  readonly status?: string;
+  readonly summary?: string;
+  /** The task the subagent was given. */
+  readonly prompt?: string;
+  /** Its own running totals, when the runtime reports them (Claude progress and end frames). */
+  readonly usage?: {
+    readonly totalTokens: number;
+    readonly toolUses?: number;
+    readonly durationMs?: number;
+  };
+}
 
 /** Input excludes cache reads/writes when those disjoint counters are supplied.
  * Thinking is a subset of output; TTL counters are subsets of cacheWrite.
@@ -130,7 +161,8 @@ export interface SessionEvent extends SessionIdentity {
     | 'duplicate-tool'
     | 'unmatched-tool'
     | 'malformed-tool'
-    | 'account-status';
+    | 'account-status'
+    | 'subagent';
   /** Local transport observation, not a native terminal acknowledgment. */
   readonly transportOutcome?: SessionAttempt['transportOutcome'];
   readonly nativeOutcome?: NativeOutcome;
@@ -174,6 +206,14 @@ export interface SessionEvent extends SessionIdentity {
   readonly limits?: LimitSnapshot;
   /** Owned, deeply frozen native JSON data (for Oracle introspection). */
   readonly raw?: unknown;
+  /**
+   * The tool call (in its parent's stream) that spawned the subagent this event came from; absent
+   * for the main thread's own events. Every subagent event, its lifecycle included, is outside any
+   * admission (`unattributedReason: "subagent"`), so it never touches a turn's content or results.
+   */
+  readonly parentToolUseId?: string;
+  /** A subagent's lifecycle (kind `subagent`). */
+  readonly subagent?: SubagentLifecycle;
 }
 
 /** Result of a single send() — the turn's content plus all classified events. */

package/src/index.ts

@@ -13,9 +13,19 @@ export {
 // Claude Code adapter (persistent stream-json session, subscription auth).
 export {
   CLAUDE_TEXT_ONLY_ARGS,
+  type ClaudeAgentDefinition,
   ClaudeCodeSession,
   type ClaudeCodeSessionConfig,
+  type ClaudeSessionExtension,
+  type ClaudeSessionHost,
 } from './claude-code-session';
+export {
+  type ClaudeInSessionConfig,
+  ClaudeInSessionDecisions,
+  IN_SESSION_AGENTS,
+  IN_SESSION_SERVER,
+  type InSessionSetup,
+} from './claude-in-session';
 export { type ClaudePrimedConfig, ClaudePrimedSessions } from './claude-primed';
 export { type ClaudeSubagentConfig, ClaudeSubagentSessions } from './claude-subagents';
 export { parseClaudeUsage } from './claude-usage';

package/src/turn-state.ts

@@ -63,8 +63,11 @@ export class TurnState {
   record(event: SessionEvent): SessionEvent {
     const e = retainEvidence({ ...this.identity, ...event, admissionId: this.admissionId });
     this.events.push(e);
-    if ((e.kind === 'text' || e.kind === 'result') && e.text) this.content = e.text;
-    if (e.kind === 'text_delta' && e.text) this.content += e.text;
+    // A subagent's text is its own; the parent turn's content is only the parent's.
+    if (!e.parentToolUseId) {
+      if ((e.kind === 'text' || e.kind === 'result') && e.text) this.content = e.text;
+      if (e.kind === 'text_delta' && e.text) this.content += e.text;
+    }
     // Usage events are per-request snapshots; the terminal result carries the turn total.
     if (e.tokens && e.kind !== 'usage') this.tokens = e.tokens;
     return e;