@ellipsis-dev/sdk 0.34.1 → 0.36.0

package/dist/store/index.js

@@ -1,7 +1,3 @@
-import {
-  SESSION_STREAM_PROTOCOL_VERSION
-} from "../chunk-6V7QTLLF.js";
-
 // src/store/claude.ts
 function claudePayload(record) {
   if (record.kind === "claude_sdk") return record.payload;
@@ -51,6 +47,42 @@ function claudePayload(record) {
 }
 
 // src/store/codexAppServer.ts
+function codexSubagentThreads(records) {
+  const threads = /* @__PURE__ */ new Set();
+  for (const record of records) addCodexSubagentThreads(threads, record);
+  return threads;
+}
+function addCodexSubagentThreads(threads, record) {
+  if (record.kind !== "codex_app_server") return false;
+  const event = record.payload;
+  if (event.method !== "item/started" && event.method !== "item/completed") {
+    return false;
+  }
+  const item = event.params.item;
+  if (item.type === "subAgentActivity") {
+    threads.add(item.agentThreadId);
+    return true;
+  }
+  if (item.type === "collabAgentToolCall") {
+    for (const thread of item.receiverThreadIds) threads.add(thread);
+    return true;
+  }
+  return false;
+}
+function isCodexSubagentSpawn(record) {
+  if (record.kind !== "codex_app_server") return false;
+  const event = record.payload;
+  if (event.method !== "item/started" && event.method !== "item/completed") {
+    return false;
+  }
+  const item = event.params.item;
+  return item.type === "subAgentActivity" && item.kind === "started";
+}
+function isCodexSubagentRecord(threads, record) {
+  if (record.kind !== "codex_app_server") return false;
+  const params = record.payload.params;
+  return "threadId" in params && typeof params.threadId === "string" && threads.has(params.threadId);
+}
 function codexAppServerContent(event) {
   if (event.method === "turn/completed") {
     return { kind: "end", isError: event.params.turn.status !== "completed" };
@@ -90,6 +122,15 @@ function codexAppServerContent(event) {
         result: item.changes.map((change) => change.diff).join("\n"),
         isError: item.status === "failed" || item.status === "declined"
       };
+    case "subAgentActivity":
+      return {
+        kind: "tool",
+        name: "Agent",
+        input: { agentPath: item.agentPath ?? null, kind: item.kind },
+        summary: item.agentPath ?? item.agentThreadId,
+        result: item.kind,
+        isError: false
+      };
     case "webSearch":
       return {
         kind: "tool",
@@ -104,124 +145,6 @@ function codexAppServerContent(event) {
   }
 }
 
-// src/store/progress.ts
-function messageProgress(records) {
-  const messages = /* @__PURE__ */ new Map();
-  const pending = /* @__PURE__ */ new Map();
-  const turns = /* @__PURE__ */ new Map();
-  let ready = false;
-  const getTurn = (id) => {
-    let turn = turns.get(id);
-    if (!turn) {
-      turn = {
-        timing: { id, startedAt: null, completedAt: null },
-        phase: ready ? "working" : "starting",
-        messages: /* @__PURE__ */ new Set()
-      };
-      turns.set(id, turn);
-    }
-    return turn;
-  };
-  const attach = (messageId, turnId) => {
-    const message = messages.get(messageId);
-    if (!message) return;
-    const turn = getTurn(turnId);
-    if (!turn.messages.has(messageId)) {
-      turn.messages.add(messageId);
-      message.turns.push(turn.timing);
-    }
-    pending.delete(messageId);
-    message.phase = turn.phase;
-  };
-  const setPending = (turnId, phase) => {
-    for (const [id, turn] of pending) {
-      if (turnId == null || turn == null || turn === turnId)
-        messages.get(id).phase = phase;
-    }
-  };
-  for (const record of records) {
-    if (record.kind === "platform") {
-      const p = record.payload;
-      const messageId = typeof p.message_id === "string" ? p.message_id : null;
-      const turnId = typeof p.turn_id === "string" ? p.turn_id : record.turn_id;
-      switch (record.record_type) {
-        case "message_received":
-          if (messageId && !messages.has(messageId)) {
-            messages.set(messageId, { phase: "queued", turns: [] });
-            if (turnId && turns.has(turnId)) attach(messageId, turnId);
-            else pending.set(messageId, turnId ?? null);
-          }
-          break;
-        case "message_delivered":
-          if (messageId && turnId) attach(messageId, turnId);
-          break;
-        case "message_requeued":
-          if (messageId && messages.has(messageId)) {
-            const requeued = typeof p.requeued_turn_id === "string" ? p.requeued_turn_id : null;
-            pending.set(messageId, requeued);
-            messages.get(messageId).phase = "queued";
-          }
-          break;
-        case "environment_phase":
-        case "environment_output":
-          ready = false;
-          setPending(turnId ?? null, "preparing");
-          break;
-        case "environment_ready":
-          ready = false;
-          setPending(turnId ?? null, "starting");
-          break;
-        case "turn_started":
-          if (turnId) {
-            getTurn(turnId).timing.startedAt = record.created_at;
-            for (const [id, turn] of pending) {
-              if (turn === turnId) attach(id, turnId);
-            }
-          }
-          break;
-        case "turn_ended":
-          if (turnId) {
-            const turn = getTurn(turnId);
-            turn.timing.completedAt = record.created_at;
-            turn.phase = null;
-            for (const id of turn.messages) {
-              if (!pending.has(id)) messages.get(id).phase = null;
-            }
-            for (const [id, pendingTurn] of pending) {
-              if (pendingTurn === turnId) {
-                pending.delete(id);
-                messages.get(id).phase = null;
-              }
-            }
-          }
-          break;
-        case "session_closed":
-          ready = false;
-          for (const id of pending.keys()) messages.get(id).phase = null;
-          break;
-      }
-      continue;
-    }
-    const claude = claudePayload(record);
-    const agentStarted = record.kind === "codex_app_server" && record.payload.method === "turn/started" || record.kind === "codex" && record.payload.type === "turn.started" || claude != null && (claude.kind === "assistant" || claude.kind === "user" || claude.kind === "system" && claude.subtype === "init");
-    if (agentStarted) {
-      ready = true;
-      if (record.turn_id) {
-        const turn = getTurn(record.turn_id);
-        if (turn.timing.completedAt == null) {
-          turn.timing.startedAt ??= record.created_at;
-          turn.phase = "working";
-          for (const id of turn.messages) messages.get(id).phase = "working";
-        }
-      }
-    }
-    if (record.session_message_id && record.turn_id) {
-      attach(record.session_message_id, record.turn_id);
-    }
-  }
-  return messages;
-}
-
 // src/store/lifecycle.ts
 function environmentOutputStep(payload) {
   if (typeof payload.step === "string" && payload.step) return payload.step;
@@ -623,6 +546,55 @@ function recordToItems(record, keyBase, options = {}) {
         }
       ] : [];
     }
+    case "gemini": {
+      const content = geminiStreamContent(record.payload);
+      if (!content) return [];
+      if (content.kind === "end") {
+        return content.isError ? [
+          {
+            key: keyBase,
+            kind: "summary",
+            text: "turn ended with an error",
+            isError: true,
+            spaceBefore: true
+          }
+        ] : [];
+      }
+      if (content.kind === "tool") {
+        return [
+          {
+            key: keyBase,
+            kind: "tool",
+            gutter: "\u25CF",
+            text: content.name,
+            detail: content.summary ? `(${content.summary})` : void 0,
+            spaceBefore: true,
+            tool: { name: content.name, input: content.input ?? void 0 }
+          }
+        ];
+      }
+      if (content.kind === "tool_result") {
+        return [
+          {
+            key: keyBase,
+            kind: "tool_result",
+            gutter: "\u23BF",
+            text: content.text || "(completed)",
+            isError: content.isError,
+            spaceBefore: false
+          }
+        ];
+      }
+      return [
+        {
+          key: keyBase,
+          kind: content.kind,
+          text: content.text.trim(),
+          isError: content.kind === "error",
+          spaceBefore: true
+        }
+      ];
+    }
     case "platform": {
       const text2 = lifecycleText(record.record_type, record.payload);
       return text2 ? [{ key: keyBase, kind: "notice", text: text2, spaceBefore: true }] : [];
@@ -728,6 +700,155 @@ function statusActivityText(status) {
   }
 }
 
+// src/store/geminiStream.ts
+function geminiStreamContent(event) {
+  switch (event.type) {
+    case "message":
+      return event.role === "assistant" && !event.delta && event.content.trim() ? { kind: "assistant", text: event.content } : null;
+    case "tool_use": {
+      const input = event.parameters ?? null;
+      return {
+        kind: "tool",
+        toolId: event.tool_id,
+        name: event.tool_name,
+        input,
+        summary: oneLine(summarizeToolInput(event.tool_name, input ?? {}), 100)
+      };
+    }
+    case "tool_result":
+      return {
+        kind: "tool_result",
+        toolId: event.tool_id,
+        text: (event.output ?? event.error?.message ?? "").trim(),
+        isError: event.status === "error"
+      };
+    case "error":
+      return { kind: "error", text: event.message };
+    case "result":
+      return { kind: "end", isError: event.status === "error" };
+    default:
+      return null;
+  }
+}
+
+// src/store/progress.ts
+function messageProgress(records) {
+  const messages = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const turns = /* @__PURE__ */ new Map();
+  let ready = false;
+  const getTurn = (id) => {
+    let turn = turns.get(id);
+    if (!turn) {
+      turn = {
+        timing: { id, startedAt: null, completedAt: null },
+        phase: ready ? "working" : "starting",
+        messages: /* @__PURE__ */ new Set()
+      };
+      turns.set(id, turn);
+    }
+    return turn;
+  };
+  const attach = (messageId, turnId) => {
+    const message = messages.get(messageId);
+    if (!message) return;
+    const turn = getTurn(turnId);
+    if (!turn.messages.has(messageId)) {
+      turn.messages.add(messageId);
+      message.turns.push(turn.timing);
+    }
+    pending.delete(messageId);
+    message.phase = turn.phase;
+  };
+  const setPending = (turnId, phase) => {
+    for (const [id, turn] of pending) {
+      if (turnId == null || turn == null || turn === turnId)
+        messages.get(id).phase = phase;
+    }
+  };
+  for (const record of records) {
+    if (record.kind === "platform") {
+      const p = record.payload;
+      const messageId = typeof p.message_id === "string" ? p.message_id : null;
+      const turnId = typeof p.turn_id === "string" ? p.turn_id : record.turn_id;
+      switch (record.record_type) {
+        case "message_received":
+          if (messageId && !messages.has(messageId)) {
+            messages.set(messageId, { phase: "queued", turns: [] });
+            if (turnId && turns.has(turnId)) attach(messageId, turnId);
+            else pending.set(messageId, turnId ?? null);
+          }
+          break;
+        case "message_delivered":
+          if (messageId && turnId) attach(messageId, turnId);
+          break;
+        case "message_requeued":
+          if (messageId && messages.has(messageId)) {
+            const requeued = typeof p.requeued_turn_id === "string" ? p.requeued_turn_id : null;
+            pending.set(messageId, requeued);
+            messages.get(messageId).phase = "queued";
+          }
+          break;
+        case "environment_phase":
+        case "environment_output":
+          ready = false;
+          setPending(turnId ?? null, "preparing");
+          break;
+        case "environment_ready":
+          ready = false;
+          setPending(turnId ?? null, "starting");
+          break;
+        case "turn_started":
+          if (turnId) {
+            getTurn(turnId).timing.startedAt = record.created_at;
+            for (const [id, turn] of pending) {
+              if (turn === turnId) attach(id, turnId);
+            }
+          }
+          break;
+        case "turn_ended":
+          if (turnId) {
+            const turn = getTurn(turnId);
+            turn.timing.completedAt = record.created_at;
+            turn.phase = null;
+            for (const id of turn.messages) {
+              if (!pending.has(id)) messages.get(id).phase = null;
+            }
+            for (const [id, pendingTurn] of pending) {
+              if (pendingTurn === turnId) {
+                pending.delete(id);
+                messages.get(id).phase = null;
+              }
+            }
+          }
+          break;
+        case "session_closed":
+          ready = false;
+          for (const id of pending.keys()) messages.get(id).phase = null;
+          break;
+      }
+      continue;
+    }
+    const claude = claudePayload(record);
+    const agentStarted = record.kind === "codex_app_server" && record.payload.method === "turn/started" || record.kind === "codex" && record.payload.type === "turn.started" || record.kind === "gemini" && record.payload.type === "init" || claude != null && (claude.kind === "assistant" || claude.kind === "user" || claude.kind === "system" && claude.subtype === "init");
+    if (agentStarted) {
+      ready = true;
+      if (record.turn_id) {
+        const turn = getTurn(record.turn_id);
+        if (turn.timing.completedAt == null) {
+          turn.timing.startedAt ??= record.created_at;
+          turn.phase = "working";
+          for (const id of turn.messages) messages.get(id).phase = "working";
+        }
+      }
+    }
+    if (record.session_message_id && record.turn_id) {
+      attach(record.session_message_id, record.turn_id);
+    }
+  }
+  return messages;
+}
+
 // src/store/chatTurns.ts
 var isInitEvent = (data) => data.kind === "system" && data.subtype === "init";
 var ENVIRONMENT_RECORD_TYPES = /* @__PURE__ */ new Set([
@@ -738,6 +859,8 @@ var ENVIRONMENT_RECORD_TYPES = /* @__PURE__ */ new Set([
 function groupRecordsToChatTurns(records, session) {
   const turns = [];
   const toolNodeByUseId = /* @__PURE__ */ new Map();
+  const openGeminiTools = /* @__PURE__ */ new Map();
+  const codexSubagentThreads2 = /* @__PURE__ */ new Set();
   const userTurnByMessageId = /* @__PURE__ */ new Map();
   const turnByMessageId = /* @__PURE__ */ new Map();
   const unansweredTurnIds = /* @__PURE__ */ new Set();
@@ -773,6 +896,20 @@ function groupRecordsToChatTurns(records, session) {
     }
     return turns[openIdx];
   };
+  const subagentTurn = (record) => {
+    for (let i = turns.length - 1; i >= 0; i--) {
+      const turn = turns[i];
+      if (turn.role === "assistant" && turn.turnId === (record.turn_id ?? void 0))
+        return turn;
+    }
+    return null;
+  };
+  const newestAssistantTurn = () => {
+    for (let i = turns.length - 1; i >= 0; i--) {
+      if (turns[i].role === "assistant") return turns[i];
+    }
+    return null;
+  };
   for (const record of records) {
     if (record.kind === "platform") {
       const messageId = typeof record.payload.message_id === "string" ? record.payload.message_id : null;
@@ -897,17 +1034,75 @@ function groupRecordsToChatTurns(records, session) {
       });
       continue;
     }
+    if (record.kind === "gemini") {
+      const content = geminiStreamContent(record.payload);
+      if (!content) continue;
+      if (content.kind === "end") {
+        if (openIdx >= 0) {
+          turns[openIdx].completedAt = record.created_at;
+          if (content.isError) turns[openIdx].isError = true;
+          openIdx = -1;
+        }
+      } else if (content.kind === "tool") {
+        const node = {
+          key: nextKey(record.id),
+          kind: "tool",
+          name: content.name,
+          input: content.input,
+          summary: content.summary,
+          result: null,
+          isError: false,
+          startedAt: record.created_at,
+          completedAt: null
+        };
+        openSessionTurn(record).nodes.push(node);
+        openGeminiTools.set(content.toolId, node);
+      } else if (content.kind === "tool_result") {
+        const node = openGeminiTools.get(content.toolId);
+        if (node) {
+          node.result = content.text;
+          node.isError = content.isError;
+          node.completedAt = record.created_at;
+          openGeminiTools.delete(content.toolId);
+        }
+      } else {
+        const turn2 = openSessionTurn(record);
+        if (content.kind === "error") turn2.isError = true;
+        turn2.nodes.push({
+          key: nextKey(record.id),
+          kind: "assistant",
+          text: content.text.trim(),
+          createdAt: record.created_at
+        });
+      }
+      continue;
+    }
     if (record.kind === "codex_app_server") {
+      const fromSubagent = isCodexSubagentRecord(codexSubagentThreads2, record);
+      const announces = addCodexSubagentThreads(codexSubagentThreads2, record);
       const content = codexAppServerContent(record.payload);
       if (!content) continue;
+      const late = fromSubagent || announces && !isCodexSubagentSpawn(record);
+      const turnFor = () => {
+        if (!late) return openSessionTurn(record);
+        const open = openIdx >= 0 ? turns[openIdx] : null;
+        if (open !== null && open.turnId === (record.turn_id ?? void 0)) {
+          return open;
+        }
+        if (record.turn_id == null) {
+          return open ?? newestAssistantTurn() ?? openSessionTurn(record);
+        }
+        return subagentTurn(record) ?? openSessionTurn(record);
+      };
       if (content.kind === "end") {
+        if (fromSubagent) continue;
         if (openIdx >= 0) {
           turns[openIdx].completedAt = record.created_at;
           if (content.isError) turns[openIdx].isError = true;
           openIdx = -1;
         }
       } else if (content.kind === "tool") {
-        openSessionTurn(record).nodes.push({
+        turnFor().nodes.push({
           key: nextKey(record.id),
           kind: "tool",
           name: content.name,
@@ -919,8 +1114,8 @@ function groupRecordsToChatTurns(records, session) {
           completedAt: record.created_at
         });
       } else if (content.text.trim()) {
-        const turn2 = openSessionTurn(record);
-        if (content.kind === "error") turn2.isError = true;
+        const turn2 = turnFor();
+        if (content.kind === "error" && !fromSubagent) turn2.isError = true;
         turn2.nodes.push({
           key: nextKey(record.id),
           kind: content.kind === "error" ? "assistant" : content.kind,
@@ -1866,7 +2061,6 @@ function isConversationOver(session) {
 function seedTranscriptStore(store, seed) {
   store.ingest({
     type: "snapshot",
-    protocol: SESSION_STREAM_PROTOCOL_VERSION,
     earliest_feed_seq: seed.earliestFeedSeq ?? null,
     session: seed.session,
     messages: [...seed.messages ?? []]
@@ -1894,13 +2088,13 @@ var SessionTranscriptStore = class {
   snapshot = EMPTY_SNAPSHOT;
   listeners = /* @__PURE__ */ new Set();
   acknowledged = /* @__PURE__ */ new Set();
-  // The inbox projection (protocol v3): message_received/delivered/requeued
+  // The inbox projection: message_received/delivered/requeued
   // RECORDS drive it; the snapshot seeds the pending set at connect. Keyed by
   // message id so a requeue can restore a message the delivered record
   // removed from the pending view.
   inbox = /* @__PURE__ */ new Map();
   // The resume cursor: the highest feed_seq received via records_append. Only
-  // records advance it (§3.4) — never messages/session frames. streamSession
+  // records advance it — never messages/session frames. streamSession
   // tracks its own copy; this one seeds a NEW streamSession call (e.g. a
   // page-level reconnect after unmount) from already-held state.
   cursorSeq = 0;
@@ -1933,7 +2127,7 @@ var SessionTranscriptStore = class {
   // The current pending set, in feed order — what queued chips render.
   pendingMessages = () => [...this.inbox.values()].filter((m) => m.status === "pending").sort((a, b) => (a.feed_seq ?? 0) - (b.feed_seq ?? 0));
   // Fold one lifecycle record into the inbox projection; returns whether the
-  // pending view changed. Unknown fields/types are ignored (§3.6).
+  // pending view changed. Unknown fields/types are ignored.
   applyMessageRecord = (record) => {
     if (record.kind !== "platform") return false;
     const payload = record.payload;
@@ -1984,7 +2178,7 @@ var SessionTranscriptStore = class {
     }
   };
   // Ingest one frame from the stream client. Unknown frame types stamp
-  // liveness and change nothing else (§3.6).
+  // liveness and change nothing else.
   ingest = (rawFrame) => {
     const prev = this.snapshot;
     const next = {
@@ -2093,6 +2287,7 @@ export {
   codexChangedPaths,
   codexEventToItems,
   codexMcpToolName,
+  codexSubagentThreads,
   collapseToolRuns,
   deliveredUnechoedSends,
   deriveEnvironmentState,
@@ -2113,6 +2308,7 @@ export {
   gutterFor,
   hookPhrase,
   humanDuration,
+  isCodexSubagentRecord,
   isConnectVisibleRecord,
   isConversationOver,
   isFoldable,

package/dist/stream/index.d.ts

@@ -1,10 +1,7 @@
-import { cS as StreamFrame, ca as Session } from '../types-DV2H5ZsR.js';
+import { d4 as StreamFrame, co as Session } from '../types-CbePyY-S.js';
 
-declare const SESSION_STREAM_PROTOCOL_VERSION = 7;
 declare const WS_CLOSE_NORMAL = 1000;
 declare const WS_CLOSE_GOING_AWAY = 1001;
-declare const WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION = 1002;
-declare const WS_CLOSE_NO_PROTOCOL = 1003;
 declare const WS_CLOSE_AUTH_FAILED = 1008;
 declare const WS_CLOSE_SERVER_ERROR = 1011;
 declare const WS_CLOSE_OVER_CAPACITY = 1013;
@@ -38,11 +35,11 @@ type OpenSocket = (args: {
     query: string;
 }) => StreamSocket | Promise<StreamSocket>;
 declare function streamQuery(afterSeq: number): string;
-type CloseKind = 'normal' | 'auth' | 'unsupported' | 'retry';
+type CloseKind = 'normal' | 'auth' | 'retry';
 declare function classifyCloseCode(code: number): CloseKind;
 declare function nextReconnectDelayMs(attempt: number): number;
 interface ReconnectDecision {
-    action: 'reconnect' | 'fallback' | 'fail-auth';
+    action: 'reconnect' | 'give-up' | 'fail-auth';
     delayMs?: number;
 }
 declare function decideReconnect(params: {
@@ -61,4 +58,4 @@ interface StreamSessionOptions {
 }
 declare function streamSession(opts: StreamSessionOptions): Promise<StreamOutcome>;
 
-export { type CloseKind, type OpenSocket, type ReconnectDecision, SESSION_STREAM_PROTOCOL_VERSION, StreamAuthError, StreamFrame, type StreamOutcome, type StreamSessionOptions, type StreamSocket, StreamUnavailableError, WS_CLOSE_AUTH_FAILED, WS_CLOSE_GOING_AWAY, WS_CLOSE_NORMAL, WS_CLOSE_NO_PROTOCOL, WS_CLOSE_OVER_CAPACITY, WS_CLOSE_SERVER_ERROR, WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION, classifyCloseCode, decideReconnect, nextReconnectDelayMs, sessionStatusWord, streamQuery, streamSession };
+export { type CloseKind, type OpenSocket, type ReconnectDecision, StreamAuthError, StreamFrame, type StreamOutcome, type StreamSessionOptions, type StreamSocket, StreamUnavailableError, WS_CLOSE_AUTH_FAILED, WS_CLOSE_GOING_AWAY, WS_CLOSE_NORMAL, WS_CLOSE_OVER_CAPACITY, WS_CLOSE_SERVER_ERROR, classifyCloseCode, decideReconnect, nextReconnectDelayMs, sessionStatusWord, streamQuery, streamSession };