@ellipsis-dev/sdk 0.15.0 → 0.16.0

package/dist/store/index.js

@@ -1,3 +1,7 @@
+import {
+  SESSION_STREAM_PROTOCOL_VERSION
+} from "../chunk-RMPAMUAE.js";
+
 // src/store/lifecycle.ts
 function sandboxOutputStep(payload) {
   if (typeof payload.step === "string" && payload.step) return payload.step;
@@ -366,6 +370,8 @@ function recordToItems(record, keyBase, options = {}) {
       const text = lifecycleText(record.record_type, record.payload);
       return text ? [{ key: keyBase, kind: "notice", text, spaceBefore: true }] : [];
     }
+    default:
+      return [];
   }
 }
 function isConnectVisibleRecord(record) {
@@ -481,7 +487,8 @@ function groupRecordsToChatTurns(records) {
         durationMs: null,
         costUsd: null,
         tokens: null,
-        resumed: pendingResume
+        resumed: pendingResume,
+        isError: false
       });
       pendingResume = false;
       openIdx = turns.length - 1;
@@ -547,16 +554,18 @@ function groupRecordsToChatTurns(records) {
         durationMs: null,
         costUsd: null,
         tokens: null,
-        resumed: false
+        resumed: false,
+        isError: false
       });
       continue;
     }
     if (record.record_format === "codex_jsonl@1") {
       codexEventIntoTurns(record, record.payload, {
         openAgentTurn,
-        closeTurn: (completedAt) => {
+        closeTurn: (completedAt, isError) => {
           if (openIdx >= 0) {
             turns[openIdx].completedAt = completedAt;
+            if (isError) turns[openIdx].isError = true;
             openIdx = -1;
           }
         },
@@ -579,6 +588,7 @@ function groupRecordsToChatTurns(records) {
         if (typeof data.cost_usd === "number") {
           turns[openIdx].costUsd = data.cost_usd;
         }
+        if (data.is_error) turns[openIdx].isError = true;
         openIdx = -1;
       }
       continue;
@@ -590,6 +600,7 @@ function groupRecordsToChatTurns(records) {
           openIdx = -1;
           turns.push({
             resumed: false,
+            isError: false,
             key: nextKey(record.id),
             role: "user",
             nodes: [
@@ -670,7 +681,7 @@ function groupRecordsToChatTurns(records) {
 }
 function codexEventIntoTurns(record, event, ops) {
   if (event.type === "turn.completed" || event.type === "turn.failed") {
-    ops.closeTurn(record.created_at);
+    ops.closeTurn(record.created_at, event.type === "turn.failed");
     return;
   }
   if (event.type === "error") {
@@ -768,6 +779,289 @@ function codexEventIntoTurns(record, event, ops) {
   }
 }
 
+// src/store/derive.ts
+function recordSlice(records) {
+  return records;
+}
+function humanDuration(seconds) {
+  const clamped = Math.max(0, seconds);
+  if (clamped === 0) return "0s";
+  if (clamped < 1) return `${Math.round(clamped * 1e3)}ms`;
+  if (clamped < 5) {
+    const s2 = clamped.toFixed(1);
+    return s2.endsWith(".0") ? `${Math.round(clamped)}s` : `${s2}s`;
+  }
+  const total = Math.round(clamped);
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  const bits = [];
+  if (h > 0) bits.push(`${h}h`);
+  if (m > 0) bits.push(`${m}m`);
+  if (s > 0 || bits.length === 0) bits.push(`${s}s`);
+  return bits.join(" ");
+}
+function sessionLogText(recordType, payload) {
+  const p = payload;
+  switch (recordType) {
+    case "session_idle":
+      return "Session asleep";
+    case "session_starting": {
+      const wake = typeof p.wake_index === "number" ? p.wake_index : 0;
+      const attempt = typeof p.attempt === "number" ? p.attempt : 0;
+      if (attempt > 0) return "Restarting the sandbox after a transient error\u2026";
+      return wake > 0 ? "Waking the session\u2026" : null;
+    }
+    case "session_retrying":
+      return typeof p.reason === "string" && p.reason ? `Retrying \xB7 ${p.reason}` : "Retrying after a transient error\u2026";
+    case "session_resumed":
+      return "Session awake";
+    case "session_cancelled": {
+      const reason = typeof p.reason === "string" && p.reason ? ` \xB7 ${p.reason}` : "";
+      return `Session cancelled${reason}`;
+    }
+    default:
+      return null;
+  }
+}
+function awaitingAgentPhase(records) {
+  let inFlight = false;
+  let sawAgent = false;
+  for (const r of records) {
+    if (r.source !== "lifecycle") {
+      sawAgent = true;
+    } else {
+      if (r.record_type === "turn_started") inFlight = true;
+      else if (r.record_type === "turn_completed" || r.record_type === "turn_failed") {
+        inFlight = false;
+      } else if (r.record_type === "session_starting" || r.record_type === "session_retrying") {
+        inFlight = false;
+        sawAgent = false;
+      }
+    }
+  }
+  if (!inFlight) return null;
+  return sawAgent ? "turn" : "boot";
+}
+function deliveredUnechoedSends(records) {
+  const received = /* @__PURE__ */ new Map();
+  const delivered = /* @__PURE__ */ new Map();
+  const failedTurns = /* @__PURE__ */ new Set();
+  const echoed = /* @__PURE__ */ new Set();
+  for (const r of records) {
+    if (r.session_message_id != null) echoed.add(r.session_message_id);
+    if (r.source !== "lifecycle") continue;
+    if (r.record_type === "turn_failed") {
+      if (typeof r.payload.turn_id === "string")
+        failedTurns.add(r.payload.turn_id);
+      continue;
+    }
+    const id = typeof r.payload.message_id === "string" ? r.payload.message_id : null;
+    if (!id) continue;
+    if (r.record_type === "message_received") {
+      if (!received.has(id))
+        received.set(
+          id,
+          typeof r.payload.body === "string" ? r.payload.body : ""
+        );
+    } else if (r.record_type === "message_delivered") {
+      delivered.set(
+        id,
+        typeof r.payload.turn_id === "string" ? r.payload.turn_id : ""
+      );
+    } else if (r.record_type === "message_requeued") delivered.delete(id);
+  }
+  const out = [];
+  for (const [id, body] of received) {
+    const turnId = delivered.get(id);
+    if (turnId === void 0 || echoed.has(id)) continue;
+    out.push({ id, body, cancelled: failedTurns.has(turnId) });
+  }
+  return out;
+}
+function msLabel(ms) {
+  if (typeof ms !== "number" || !isFinite(ms) || ms < 0) return null;
+  return humanDuration(ms / 1e3);
+}
+function imageStepLabel(step) {
+  switch (step) {
+    case "build":
+      return "Building image";
+    case "container":
+      return "Starting container";
+    case "smoke":
+      return "Smoke check";
+    default:
+      return step;
+  }
+}
+function hookPhrase(step) {
+  switch (step) {
+    case "setup":
+    case "image.setup":
+      return "Building image";
+    case "clone":
+      return "Fetching repositories";
+    case "post_start":
+      return "Post-start setup";
+    case "post_clone":
+      return "Post-clone setup";
+    default:
+      return step;
+  }
+}
+function stepLabel(phase, step) {
+  if (step) {
+    if (phase === "hooks") return hookPhrase(step);
+    if (phase === "image") return imageStepLabel(step);
+    return step;
+  }
+  return sandboxPhaseLabel(phase);
+}
+function deriveSandboxState(records, minFeedSeq) {
+  let seen = false;
+  let headline = "Starting cloud agent\u2026";
+  let done = false;
+  let sandboxDone = false;
+  let readySeconds = null;
+  let configName = null;
+  let configCommitSha = null;
+  let log = [];
+  let open = /* @__PURE__ */ new Map();
+  const push = (record, kind, text) => {
+    const entry = { key: `${record.feed_seq}:${log.length}`, kind, text };
+    log.push(entry);
+    return entry;
+  };
+  const reset = () => {
+    log = [];
+    open = /* @__PURE__ */ new Map();
+    sandboxDone = false;
+  };
+  for (const record of records) {
+    if (record.feed_seq <= minFeedSeq || record.source !== "lifecycle")
+      continue;
+    const p = record.payload;
+    switch (record.record_type) {
+      case "session_scheduled": {
+        seen = true;
+        headline = "Session scheduled\u2026";
+        done = false;
+        configName = typeof p.config_name === "string" && p.config_name ? p.config_name : null;
+        configCommitSha = typeof p.config_commit_sha === "string" && p.config_commit_sha ? p.config_commit_sha : null;
+        break;
+      }
+      case "session_starting":
+      case "session_retrying": {
+        seen = true;
+        const text = lifecycleText(record.record_type, p);
+        headline = !text || text === "Session starting\u2026" ? "Starting cloud agent\u2026" : text;
+        done = false;
+        readySeconds = null;
+        reset();
+        break;
+      }
+      case "session_resumed":
+      case "session_idle": {
+        seen = true;
+        done = true;
+        break;
+      }
+      case "sandbox_starting": {
+        seen = true;
+        reset();
+        push(record, "step", "Starting sandbox\u2026");
+        break;
+      }
+      case "sandbox_phase": {
+        seen = true;
+        const phase = typeof p.phase === "string" && p.phase ? p.phase : "setup";
+        const step = typeof p.step === "string" && p.step ? p.step : null;
+        const key = step ? `${phase}:${step}` : phase;
+        const label = stepLabel(phase, step);
+        if (p.status === "completed" || p.status === "failed") {
+          const detail = p.detail && typeof p.detail === "object" ? p.detail : {};
+          const tier = cacheTierLabel(detail.cache_tier);
+          const dur = msLabel(p.duration_ms);
+          const failed = p.status === "failed";
+          const base = failed ? `${label} failed` : label;
+          const text = [
+            base,
+            ...tier ? [tier] : [],
+            ...dur ? [dur] : []
+          ].join(" \xB7 ");
+          const line = open.get(key);
+          if (line) {
+            line.kind = failed ? "failed" : "done";
+            line.text = text;
+            open.delete(key);
+          } else {
+            push(record, failed ? "failed" : "done", text);
+          }
+        } else if (!open.has(key)) {
+          open.set(key, push(record, "step", `${label}\u2026`));
+        }
+        break;
+      }
+      case "sandbox_output": {
+        seen = true;
+        for (const l of sandboxOutputLines(p)) push(record, "output", l);
+        break;
+      }
+      case "sandbox_ready": {
+        seen = true;
+        for (const [, line] of open) line.kind = "done";
+        open = /* @__PURE__ */ new Map();
+        const timings = p.phase_timings && typeof p.phase_timings === "object" ? Object.values(p.phase_timings) : [];
+        const totalSeconds = timings.reduce(
+          (acc, v) => typeof v === "number" && isFinite(v) ? acc + v : acc,
+          0
+        );
+        const tier = cacheTierLabel(p.cache_tier);
+        push(
+          record,
+          "done",
+          [
+            "Sandbox ready",
+            ...tier ? [tier] : [],
+            ...totalSeconds > 0 ? [humanDuration(totalSeconds)] : []
+          ].join(" \xB7 ")
+        );
+        sandboxDone = true;
+        readySeconds = totalSeconds > 0 ? totalSeconds : null;
+        done = true;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  const full = configName ? [
+    {
+      key: "config",
+      kind: "done",
+      text: `Using ${configName}${configCommitSha ? ` @ ${configCommitSha.slice(0, 7)}` : ""}`
+    },
+    ...log
+  ] : log;
+  return seen ? {
+    headline,
+    done,
+    readySeconds,
+    sandboxDone,
+    configName,
+    configCommitSha,
+    log: full
+  } : null;
+}
+function sandboxSummary(sandbox) {
+  const seconds = sandbox?.readySeconds ?? null;
+  return seconds ? `Sandbox ready in ${humanDuration(seconds)}` : "Sandbox started";
+}
+function lastLines(log, max) {
+  return log.length <= max ? [...log] : log.slice(log.length - max);
+}
+
 // src/store/index.ts
 var TERMINAL_SESSION_STATUSES = /* @__PURE__ */ new Set([
   "completed",
@@ -781,6 +1075,18 @@ function isConversationOver(session) {
   }
   return TERMINAL_SESSION_STATUSES.has(session.status);
 }
+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 ?? []]
+  });
+  const ordered = [...seed.records].sort((a, b) => a.feed_seq - b.feed_seq);
+  if (ordered.length)
+    store.ingest({ type: "records_append", records: ordered });
+}
 var EMPTY_SNAPSHOT = {
   session: null,
   records: [],
@@ -961,28 +1267,38 @@ var SessionTranscriptStore = class {
 };
 export {
   SessionTranscriptStore,
+  awaitingAgentPhase,
   cacheTierLabel,
   clampLines,
   codexChangedPaths,
   codexEventToItems,
   codexMcpToolName,
   collapseToolRuns,
+  deliveredUnechoedSends,
+  deriveSandboxState,
   emptySessionTranscriptSnapshot,
   eventToItems,
   foldCosts,
   formatDuration,
   groupRecordsToChatTurns,
+  hookPhrase,
+  humanDuration,
   isConnectVisibleRecord,
   isConversationOver,
+  lastLines,
   lifecycleText,
   oneLine,
   pendingToolCalls,
+  recordSlice,
   recordToItems,
   resultCostUsd,
   sandboxOutputLine,
   sandboxOutputLines,
   sandboxOutputStep,
   sandboxPhaseLabel,
+  sandboxSummary,
+  seedTranscriptStore,
+  sessionLogText,
   statusActivityText,
   summarizeToolInput,
   toolResultText

package/dist/stream/index.d.ts

@@ -1,4 +1,4 @@
-import { a7 as StreamFrame, K as Session } from '../types-DtVn9Yj3.js';
+import { a7 as StreamFrame, K as Session } from '../types-DB1hOyQE.js';
 
 declare const SESSION_STREAM_PROTOCOL_VERSION = 3;
 declare const WS_CLOSE_NORMAL = 1000;

package/dist/stream/index.js

@@ -1,192 +1,21 @@
-// src/stream/index.ts
-var SESSION_STREAM_PROTOCOL_VERSION = 3;
-var WS_CLOSE_NORMAL = 1e3;
-var WS_CLOSE_GOING_AWAY = 1001;
-var WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION = 1002;
-var WS_CLOSE_NO_PROTOCOL = 1003;
-var WS_CLOSE_AUTH_FAILED = 1008;
-var WS_CLOSE_SERVER_ERROR = 1011;
-var WS_CLOSE_OVER_CAPACITY = 1013;
-function sessionStatusWord(session) {
-  return session.surface?.status ?? session.status;
-}
-var StreamUnavailableError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "StreamUnavailableError";
-  }
-};
-var StreamAuthError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "StreamAuthError";
-  }
-};
-function streamQuery(afterSeq) {
-  const base = `protocol=${SESSION_STREAM_PROTOCOL_VERSION}`;
-  return afterSeq > 0 ? `${base}&after_seq=${afterSeq}` : base;
-}
-var HEARTBEAT_TIMEOUT_MS = 45e3;
-var DEFAULT_MAX_RECONNECTS = 5;
-function classifyCloseCode(code) {
-  switch (code) {
-    case WS_CLOSE_NORMAL:
-      return "normal";
-    case WS_CLOSE_AUTH_FAILED:
-    case 4401:
-    // dashboard ticket door: bad/expired ticket
-    case 4403:
-      return "auth";
-    case WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION:
-    case WS_CLOSE_NO_PROTOCOL:
-      return "unsupported";
-    default:
-      return "retry";
-  }
-}
-function nextReconnectDelayMs(attempt) {
-  const base = 500;
-  const max = 8e3;
-  return Math.min(max, base * 2 ** Math.max(0, attempt - 1));
-}
-function decideReconnect(params) {
-  const { closeKind, everReceivedFrame, attempt, maxReconnects } = params;
-  if (closeKind === "auth") return { action: "fail-auth" };
-  if (closeKind === "unsupported") return { action: "fallback" };
-  const cap = everReceivedFrame ? maxReconnects : Math.min(2, maxReconnects);
-  if (attempt >= cap) return { action: "fallback" };
-  return { action: "reconnect", delayMs: nextReconnectDelayMs(attempt) };
-}
-function connectOnce(sock, emit, signal) {
-  return new Promise((resolve) => {
-    let settled = false;
-    let heartbeat;
-    const finish = (result) => {
-      if (settled) return;
-      settled = true;
-      if (heartbeat) clearTimeout(heartbeat);
-      if (signal) signal.removeEventListener("abort", onAbort);
-      sock.close();
-      resolve(result);
-    };
-    const onAbort = () => finish({ kind: "aborted" });
-    const bumpHeartbeat = () => {
-      if (heartbeat) clearTimeout(heartbeat);
-      heartbeat = setTimeout(
-        () => finish({ kind: "error", err: new Error("heartbeat timeout") }),
-        HEARTBEAT_TIMEOUT_MS
-      );
-    };
-    if (signal) {
-      if (signal.aborted) {
-        finish({ kind: "aborted" });
-        return;
-      }
-      signal.addEventListener("abort", onAbort);
-    }
-    sock.onOpen(() => bumpHeartbeat());
-    sock.onMessage((data) => {
-      bumpHeartbeat();
-      let frame;
-      try {
-        frame = JSON.parse(data);
-      } catch {
-        return;
-      }
-      emit(frame);
-      if (frame.type === "done") {
-        finish({ kind: "done" });
-      } else if (frame.type === "error") {
-        finish({
-          kind: "frameError",
-          message: frame.message ?? "stream error"
-        });
-      }
-    });
-    sock.onClose((code) => finish({ kind: "closed", code }));
-    sock.onError((err) => finish({ kind: "error", err }));
-  });
-}
-function sleep(ms, signal) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    signal?.addEventListener(
-      "abort",
-      () => {
-        clearTimeout(timer);
-        resolve();
-      },
-      { once: true }
-    );
-  });
-}
-async function streamSession(opts) {
-  const maxReconnects = opts.maxReconnects ?? DEFAULT_MAX_RECONNECTS;
-  let afterSeq = opts.afterSeq ?? 0;
-  let everReceivedFrame = false;
-  let attempt = 0;
-  let lastStatusWord = "";
-  let lastExitStatus = null;
-  const emit = (frame) => {
-    everReceivedFrame = true;
-    attempt = 0;
-    if (frame.type === "records_append") {
-      const records = frame.records;
-      for (const record of records) {
-        if (typeof record.feed_seq === "number") {
-          afterSeq = Math.max(afterSeq, record.feed_seq);
-        }
-      }
-    } else if (frame.type === "snapshot" || frame.type === "session") {
-      const session = frame.session;
-      lastStatusWord = sessionStatusWord(session);
-      lastExitStatus = session.exit_status ?? null;
-    }
-    opts.onFrame(frame);
-  };
-  for (; ; ) {
-    if (opts.signal?.aborted) return { type: "aborted" };
-    let res;
-    try {
-      const sock = await opts.openSocket({
-        sessionId: opts.sessionId,
-        afterSeq,
-        query: streamQuery(afterSeq)
-      });
-      res = await connectOnce(sock, emit, opts.signal);
-    } catch (err) {
-      res = {
-        kind: "error",
-        err: err instanceof Error ? err : new Error(String(err))
-      };
-    }
-    if (res.kind === "done") {
-      return {
-        type: "done",
-        status: lastStatusWord,
-        exitStatus: lastExitStatus
-      };
-    }
-    if (res.kind === "frameError")
-      return { type: "error", message: res.message };
-    if (res.kind === "aborted") return { type: "aborted" };
-    attempt++;
-    const decision = decideReconnect({
-      closeKind: res.kind === "closed" ? classifyCloseCode(res.code) : void 0,
-      everReceivedFrame,
-      attempt,
-      maxReconnects
-    });
-    if (decision.action === "fail-auth") {
-      throw new StreamAuthError("not authorized to stream this session");
-    }
-    if (decision.action === "fallback") {
-      const why = res.kind === "error" ? res.err.message : `stream closed (code ${res.code})`;
-      throw new StreamUnavailableError(why);
-    }
-    await sleep(decision.delayMs ?? 0, opts.signal);
-  }
-}
+import {
+  SESSION_STREAM_PROTOCOL_VERSION,
+  StreamAuthError,
+  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
+} from "../chunk-RMPAMUAE.js";
 export {
   SESSION_STREAM_PROTOCOL_VERSION,
   StreamAuthError,