@ellipsis-dev/sdk 0.15.0 → 0.16.0

package/dist/chunk-RMPAMUAE.js

@@ -0,0 +1,208 @@
+// 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);
+  }
+}
+
+export {
+  SESSION_STREAM_PROTOCOL_VERSION,
+  WS_CLOSE_NORMAL,
+  WS_CLOSE_GOING_AWAY,
+  WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION,
+  WS_CLOSE_NO_PROTOCOL,
+  WS_CLOSE_AUTH_FAILED,
+  WS_CLOSE_SERVER_ERROR,
+  WS_CLOSE_OVER_CAPACITY,
+  sessionStatusWord,
+  StreamUnavailableError,
+  StreamAuthError,
+  streamQuery,
+  classifyCloseCode,
+  nextReconnectDelayMs,
+  decideReconnect,
+  streamSession
+};

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { c as components } from './types-DtVn9Yj3.js';
-export { A as AgentConfigSource, a as AttributionType, B as BudgetSource, C as ClaudeSessionRecord, b as CodexEvent, d as CodexItem, e as CodexSessionRecord, f as CreateReviewRequest, D as DeltaFrame, g as DoneFrame, E as ErrorFrame, F as Finding, G as GithubAccountSnippet, h as GithubAccountType, H as Harness, i as HeartbeatFrame, L as LifecycleSessionRecord, P as ParentKind, j as PromptBlockedReason, R as RecordsAppendFrame, k as ResolvedReviewScope, l as Review, m as ReviewConfiguration, n as ReviewCounters, o as ReviewFinding, p as ReviewRequester, q as ReviewScope, r as ReviewScopeKind, s as ReviewStage, t as ReviewedCommit, u as ReviewsListResponse, S as SdkAssistantRecord, v as SdkContentBlock, w as SdkRateLimitRecord, x as SdkRecord, y as SdkResultRecord, z as SdkSystemRecord, I as SdkUserRecord, J as SendSessionMessageRequest, K as Session, M as SessionExecution, N as SessionExecutionsListResponse, O as SessionExitStatus, Q as SessionFrame, T as SessionLiveness, U as SessionMessage, V as SessionMessageResponse, W as SessionMessageStatus, X as SessionPr, Y as SessionPrompting, Z as SessionRecord, _ as SessionRecordsListResponse, $ as SessionResponse, a0 as SessionSource, a1 as SessionState, a2 as SessionStatus, a3 as SessionStreamFrame, a4 as SessionSurface, a5 as SessionsListResponse, a6 as SnapshotFrame, a7 as StreamFrame, a8 as TokensInfo, a9 as paths } from './types-DtVn9Yj3.js';
+import { c as components } from './types-DB1hOyQE.js';
+export { A as AgentConfigSource, a as AttributionType, B as BudgetSource, C as ClaudeSessionRecord, b as CodexEvent, d as CodexItem, e as CodexSessionRecord, f as CreateReviewRequest, D as DeltaFrame, g as DoneFrame, E as ErrorFrame, F as Finding, G as GithubAccountSnippet, h as GithubAccountType, H as Harness, i as HeartbeatFrame, L as LifecycleSessionRecord, P as ParentKind, j as PromptBlockedReason, R as RecordsAppendFrame, k as ResolvedReviewScope, l as Review, m as ReviewConfiguration, n as ReviewCounters, o as ReviewFinding, p as ReviewRequester, q as ReviewScope, r as ReviewScopeKind, s as ReviewStage, t as ReviewedCommit, u as ReviewsListResponse, S as SdkAssistantRecord, v as SdkContentBlock, w as SdkRateLimitRecord, x as SdkRecord, y as SdkResultRecord, z as SdkSystemRecord, I as SdkUserRecord, J as SendSessionMessageRequest, K as Session, M as SessionExecution, N as SessionExecutionsListResponse, O as SessionExitStatus, Q as SessionFrame, T as SessionGit, U as SessionLiveness, V as SessionMessage, W as SessionMessageResponse, X as SessionMessageStatus, Y as SessionPrompting, Z as SessionRecord, _ as SessionRecordsListResponse, $ as SessionResponse, a0 as SessionSource, a1 as SessionState, a2 as SessionStatus, a3 as SessionStreamFrame, a4 as SessionSurface, a5 as SessionsListResponse, a6 as SnapshotFrame, a7 as StreamFrame, a8 as TokensInfo, a9 as paths } from './types-DB1hOyQE.js';
 
 interface CursorResponse {
     has_more: boolean;

package/dist/store/index.d.ts

@@ -1,4 +1,4 @@
-import { Z as SessionRecord, aa as CodexFileChangeItem, b as CodexEvent, ab as CodexMcpToolCallItem, x as SdkRecord, K as Session, U as SessionMessage, a7 as StreamFrame } from '../types-DtVn9Yj3.js';
+import { Z as SessionRecord, aa as CodexFileChangeItem, b as CodexEvent, ab as CodexMcpToolCallItem, x as SdkRecord, K as Session, V as SessionMessage, a7 as StreamFrame } from '../types-DB1hOyQE.js';
 
 interface ChatToolNode {
     key: string;
@@ -42,9 +42,46 @@ interface ChatTurn {
     costUsd: number | null;
     tokens: number | null;
     resumed: boolean;
+    isError: boolean;
 }
 declare function groupRecordsToChatTurns(records: readonly SessionRecord[]): ChatTurn[];
 
+type RecordSlice = {
+    feed_seq: number;
+    source: string;
+    record_type: string;
+    payload: Record<string, unknown>;
+    session_message_id?: string | null;
+};
+declare function recordSlice(records: readonly SessionRecord[]): readonly RecordSlice[];
+declare function humanDuration(seconds: number): string;
+declare function sessionLogText(recordType: string, payload: Record<string, unknown>): string | null;
+declare function awaitingAgentPhase(records: readonly RecordSlice[]): 'boot' | 'turn' | null;
+declare function deliveredUnechoedSends(records: readonly RecordSlice[]): {
+    id: string;
+    body: string;
+    cancelled: boolean;
+}[];
+type SandboxLogKind = 'step' | 'output' | 'done' | 'failed';
+type SandboxLogLine = {
+    key: string;
+    kind: SandboxLogKind;
+    text: string;
+};
+type SandboxState = {
+    headline: string;
+    done: boolean;
+    readySeconds: number | null;
+    sandboxDone: boolean;
+    configName: string | null;
+    configCommitSha: string | null;
+    log: SandboxLogLine[];
+};
+declare function hookPhrase(step: string): string;
+declare function deriveSandboxState(records: readonly RecordSlice[], minFeedSeq: number): SandboxState | null;
+declare function sandboxSummary(sandbox: SandboxState | null): string;
+declare function lastLines(log: readonly SandboxLogLine[], max: number): SandboxLogLine[];
+
 declare function sandboxOutputStep(payload: Record<string, unknown>): string;
 declare function sandboxOutputLines(payload: Record<string, unknown>): string[];
 declare function sandboxOutputLine(payload: Record<string, unknown>): string | null;
@@ -104,6 +141,12 @@ interface SessionTranscriptSnapshot {
     lastEventAt: number | null;
     conversationOver: boolean;
 }
+declare function seedTranscriptStore(store: SessionTranscriptStore, seed: {
+    session: Session;
+    records: readonly SessionRecord[];
+    messages?: readonly SessionMessage[] | null;
+    earliestFeedSeq?: number | null;
+}): void;
 declare function emptySessionTranscriptSnapshot(): SessionTranscriptSnapshot;
 declare class SessionTranscriptStore {
     private snapshot;
@@ -122,4 +165,4 @@ declare class SessionTranscriptStore {
     ingest: (rawFrame: StreamFrame) => void;
 }
 
-export { type ChatNode, type ChatToolNode, type ChatTurn, type EventToItemsOptions, type ItemKind, type SessionTranscriptSnapshot, SessionTranscriptStore, StreamFrame, type TranscriptItem, cacheTierLabel, clampLines, codexChangedPaths, codexEventToItems, codexMcpToolName, collapseToolRuns, emptySessionTranscriptSnapshot, eventToItems, foldCosts, formatDuration, groupRecordsToChatTurns, isConnectVisibleRecord, isConversationOver, lifecycleText, oneLine, pendingToolCalls, recordToItems, resultCostUsd, sandboxOutputLine, sandboxOutputLines, sandboxOutputStep, sandboxPhaseLabel, statusActivityText, summarizeToolInput, toolResultText };
+export { type ChatNode, type ChatToolNode, type ChatTurn, type EventToItemsOptions, type ItemKind, type RecordSlice, type SandboxLogKind, type SandboxLogLine, type SandboxState, type SessionTranscriptSnapshot, SessionTranscriptStore, StreamFrame, type TranscriptItem, 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 };