@ellipsis-dev/sdk 0.1.0

package/dist/store/index.js

@@ -0,0 +1,643 @@
+// src/store/lifecycle.ts
+function setupOutputHook(payload) {
+  return typeof payload.hook === "string" ? payload.hook : "setup";
+}
+function setupOutputLine(payload) {
+  const lines = Array.isArray(payload.lines) ? payload.lines.filter(
+    (l) => typeof l === "string" && l.trim().length > 0
+  ) : [];
+  return lines.length ? lines[lines.length - 1].trim() : null;
+}
+function cacheTierLabel(tier) {
+  switch (tier) {
+    case "exact":
+      return "cached image";
+    case "incremental":
+      return "incremental build";
+    case "full":
+      return "full build";
+    default:
+      return null;
+  }
+}
+function lifecycleText(recordType, payload) {
+  switch (recordType) {
+    case "sandbox_starting":
+      return "Starting sandbox\u2026";
+    case "sandbox_setup_output": {
+      const last = setupOutputLine(payload);
+      return last ? `${setupOutputHook(payload)} \xB7 ${last}` : null;
+    }
+    case "sandbox_ready": {
+      const repos = Array.isArray(payload.repositories) ? payload.repositories.filter(
+        (r) => typeof r === "string"
+      ) : [];
+      const parts = ["Sandbox ready"];
+      if (repos.length) parts.push(repos.join(", "));
+      const tier = cacheTierLabel(payload.cache_tier);
+      if (tier) parts.push(tier);
+      return parts.join(" \xB7 ");
+    }
+    case "session_resumed":
+      return "Resumed the conversation";
+    case "session_paused":
+      return "Sleeping \u2014 your next message wakes it";
+    case "session_closed":
+      return "Conversation closed";
+    case "session_cancelled": {
+      const reason = typeof payload.reason === "string" ? payload.reason : null;
+      return reason ? `Session cancelled \xB7 ${reason}` : "Session cancelled";
+    }
+    default:
+      return null;
+  }
+}
+
+// src/store/transcript.ts
+var LineBuffer = class {
+  buf = "";
+  push(chunk) {
+    this.buf += chunk;
+    const parts = this.buf.split("\n");
+    this.buf = parts.pop() ?? "";
+    return parts;
+  }
+  flush() {
+    const rest = this.buf.trim();
+    this.buf = "";
+    return rest ? [rest] : [];
+  }
+};
+function parseEventLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const value = JSON.parse(trimmed);
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+  } catch {
+  }
+  return null;
+}
+function oneLine(text, max) {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  return collapsed.length <= max ? collapsed : `${collapsed.slice(0, max - 3)}...`;
+}
+function summarizeToolInput(name, input) {
+  const args = input && typeof input === "object" ? input : {};
+  const str = (v) => typeof v === "string" ? v : void 0;
+  const tool = name.toLowerCase();
+  const path = str(args.file_path) ?? str(args.path) ?? str(args.notebook_path);
+  if (["read", "write", "edit", "multiedit", "notebookedit"].includes(tool) && path) {
+    return oneLine(path, 100);
+  }
+  if (tool === "bash" && str(args.command))
+    return oneLine(str(args.command), 100);
+  if ((tool === "grep" || tool === "glob") && str(args.pattern)) {
+    const where = str(args.path) ?? str(args.glob);
+    return oneLine(str(args.pattern) + (where ? ` in ${where}` : ""), 100);
+  }
+  if ((tool === "task" || tool === "agent") && str(args.description)) {
+    return oneLine(str(args.description), 100);
+  }
+  if (tool === "webfetch" && str(args.url)) return oneLine(str(args.url), 100);
+  if (tool === "websearch" && str(args.query))
+    return oneLine(str(args.query), 100);
+  const keys = Object.keys(args);
+  if (keys.length === 0) return "";
+  return oneLine(JSON.stringify(args), 100);
+}
+function formatDuration(seconds) {
+  const s = Math.round(seconds);
+  return s >= 60 ? `${Math.floor(s / 60)}m ${s % 60}s` : `${s}s`;
+}
+function blocksOf(content) {
+  if (typeof content === "string") return [{ type: "text", text: content }];
+  if (Array.isArray(content)) return content;
+  return [];
+}
+function toolResultText(block) {
+  const c = block.content;
+  if (typeof c === "string") return c.trim();
+  if (Array.isArray(c)) {
+    const parts = [];
+    for (const inner of c) {
+      if (typeof inner.text === "string") parts.push(inner.text);
+      else parts.push(JSON.stringify(inner));
+    }
+    return parts.join("\n").trim();
+  }
+  if (c === void 0 || c === null) return "";
+  return JSON.stringify(c);
+}
+function eventToItems(event, keyBase, options = {}) {
+  const items = [];
+  const push = (item) => {
+    items.push({ ...item, key: `${keyBase}:${items.length}` });
+  };
+  const type = event.type;
+  if (type === "result") {
+    const bits = [];
+    if (typeof event.duration_ms === "number")
+      bits.push(formatDuration(event.duration_ms / 1e3));
+    if (typeof event.total_cost_usd === "number")
+      bits.push(`$${event.total_cost_usd.toFixed(2)}`);
+    const label = event.is_error ? "turn ended with an error" : "turn complete";
+    push({
+      kind: "summary",
+      text: bits.length ? `${label} \xB7 ${bits.join(" \xB7 ")}` : label,
+      spaceBefore: true,
+      isError: event.is_error
+    });
+    return items;
+  }
+  if (type === "system") {
+    if (!options.systemInitLine || event.subtype !== "init") return items;
+    const bits = [];
+    if (typeof event.model === "string") bits.push(event.model);
+    if (typeof event.cwd === "string") bits.push(event.cwd);
+    push({
+      kind: "system",
+      text: bits.length ? `session started \xB7 ${bits.join(" \xB7 ")}` : "session started",
+      spaceBefore: true
+    });
+    return items;
+  }
+  const blocks = blocksOf(event.message?.content);
+  if (type === "user") {
+    for (const block of blocks) {
+      if (block.type === "tool_result") {
+        const body = toolResultText(block);
+        push({
+          kind: "tool_result",
+          gutter: "\u23BF",
+          text: body || "(no output)",
+          spaceBefore: false,
+          isError: block.is_error
+        });
+      } else if (typeof block.text === "string" && block.text.trim()) {
+        push({
+          kind: "user",
+          gutter: "\u203A",
+          text: block.text.trim(),
+          spaceBefore: true
+        });
+      }
+    }
+    return items;
+  }
+  for (const block of blocks) {
+    if (block.type === "thinking" && typeof block.thinking === "string" && block.thinking.trim()) {
+      push({
+        kind: "thinking",
+        gutter: "\u273B",
+        text: block.thinking.trim(),
+        spaceBefore: true
+      });
+    } else if (block.type === "tool_use") {
+      const name = block.name ?? "tool";
+      const summary = summarizeToolInput(name, block.input);
+      push({
+        kind: "tool",
+        gutter: "\u25CF",
+        text: name,
+        detail: summary ? `(${summary})` : void 0,
+        spaceBefore: true,
+        tool: { name, input: block.input }
+      });
+    } else if (typeof block.text === "string" && block.text.trim()) {
+      push({ kind: "assistant", text: block.text.trim(), spaceBefore: true });
+    }
+  }
+  return items;
+}
+function recordToItems(record, keyBase, options = {}) {
+  if (record.source === "lifecycle") {
+    const text = lifecycleText(record.record_type, record.payload);
+    return text ? [{ key: keyBase, kind: "notice", text, spaceBefore: true }] : [];
+  }
+  if (record.source !== "claude_code") return [];
+  return eventToItems(record.payload, keyBase, options);
+}
+function isConnectVisibleRecord(record) {
+  return record.source !== "lifecycle" || record.record_type === "sandbox_ready";
+}
+function pendingToolCalls(items) {
+  let pending = [];
+  for (const item of items) {
+    if (item.kind === "tool") pending.push(item);
+    else if (item.kind === "tool_result") pending.shift();
+    else pending = [];
+  }
+  return pending;
+}
+function collapseToolRuns(items) {
+  const out = [];
+  let group = [];
+  const flush = () => {
+    if (group.length === 0) return;
+    const names = [
+      ...new Set(group.filter((i) => i.kind === "tool").map((i) => i.text))
+    ];
+    const n = group.filter((i) => i.kind === "tool").length || group.length;
+    const plural = n === 1 ? "" : "s";
+    let label;
+    if (names.length === 1 && names[0] === "Bash")
+      label = `Ran ${n} shell command${plural}`;
+    else if (names.length === 1 && names[0] === "Read")
+      label = `Read ${n} file${plural}`;
+    else if (names.length === 0) label = `Ran ${n} tool call${plural}`;
+    else {
+      const shown = names.slice(0, 3).join(", ") + (names.length > 3 ? ", \u2026" : "");
+      label = `Ran ${n} tool call${plural} (${shown})`;
+    }
+    out.push({
+      key: `grp:${group[0].key}`,
+      kind: "notice",
+      text: label,
+      spaceBefore: true
+    });
+    group = [];
+  };
+  for (const item of items) {
+    if (item.kind === "tool" || item.kind === "tool_result") group.push(item);
+    else {
+      flush();
+      out.push(item);
+    }
+  }
+  flush();
+  return out;
+}
+function clampLines(text, maxLines) {
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) return { body: text, more: 0 };
+  return {
+    body: lines.slice(0, maxLines).join("\n"),
+    more: lines.length - maxLines
+  };
+}
+function resultCostUsd(event) {
+  if (event.type !== "result") return null;
+  return typeof event.total_cost_usd === "number" ? event.total_cost_usd : null;
+}
+function foldCosts(events) {
+  let prev = null;
+  let total = null;
+  for (const event of events) {
+    const cost = resultCostUsd(event);
+    if (cost == null) continue;
+    prev = total;
+    total = cost;
+  }
+  const lastStep = total != null && prev != null ? Math.max(0, total - prev) : total;
+  return { total, lastStep };
+}
+function statusActivityText(status) {
+  switch (status) {
+    case "scheduled":
+      return "Waiting for a worker";
+    case "starting":
+      return "Starting sandbox";
+    case "retrying":
+      return "Retrying after a transient error";
+    default:
+      return null;
+  }
+}
+
+// src/store/chatTurns.ts
+var isInitEvent = (data) => data.type === "system" && data.subtype === "init";
+var TOOL_USE_BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "tool_use",
+  "server_tool_use",
+  "mcp_tool_use"
+]);
+function toolResultText2(block) {
+  const c = block.content;
+  if (typeof c === "string") return c.trim();
+  if (Array.isArray(c)) {
+    return c.map(
+      (inner) => typeof inner.text === "string" ? inner.text : JSON.stringify(inner)
+    ).join("\n").trim();
+  }
+  if (c === void 0 || c === null) return "";
+  return JSON.stringify(c);
+}
+function groupRecordsToChatTurns(records) {
+  const turns = [];
+  const toolNodeByUseId = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const nextKey = (base) => `${base}:${seq++}`;
+  let openIdx = -1;
+  let initCount = 0;
+  let pendingResume = false;
+  const openAgentTurn = (record) => {
+    if (openIdx < 0) {
+      turns.push({
+        key: nextKey(record.id),
+        role: "assistant",
+        nodes: [],
+        startedAt: record.created_at,
+        completedAt: null,
+        durationMs: null,
+        costUsd: null,
+        tokens: null,
+        resumed: pendingResume
+      });
+      pendingResume = false;
+      openIdx = turns.length - 1;
+    }
+    return turns[openIdx];
+  };
+  for (const record of records) {
+    if (record.source === "lifecycle") {
+      const text = lifecycleText(record.record_type, record.payload);
+      if (text) {
+        const isSetupOutput = record.record_type === "sandbox_setup_output";
+        const hook = isSetupOutput ? setupOutputHook(record.payload) : void 0;
+        const prev = turns.length > 0 ? turns[turns.length - 1] : null;
+        const prevNode = prev?.nodes[0];
+        if (isSetupOutput && prev && prevNode && prevNode.kind === "lifecycle" && prevNode.hook === hook) {
+          prevNode.text = text;
+          prev.completedAt = record.created_at;
+          continue;
+        }
+        turns.push({
+          key: nextKey(record.id),
+          role: "lifecycle",
+          nodes: [
+            {
+              key: nextKey(record.id),
+              kind: "lifecycle",
+              text,
+              recordType: record.record_type,
+              hook
+            }
+          ],
+          startedAt: record.created_at,
+          completedAt: record.created_at,
+          durationMs: null,
+          costUsd: null,
+          tokens: null,
+          resumed: false
+        });
+      }
+      continue;
+    }
+    if (record.source !== "claude_code") continue;
+    const data = record.payload;
+    if (data.type === "system") {
+      if (isInitEvent(data)) {
+        initCount += 1;
+        if (initCount > 1) pendingResume = true;
+      }
+      continue;
+    }
+    if (data.type === "result") {
+      if (openIdx >= 0) {
+        turns[openIdx].completedAt = record.created_at;
+        turns[openIdx].durationMs = typeof data.duration_ms === "number" ? data.duration_ms : null;
+        if (typeof data.total_cost_usd === "number")
+          turns[openIdx].costUsd = data.total_cost_usd;
+        openIdx = -1;
+      }
+      continue;
+    }
+    const message = data.message;
+    if (!message) continue;
+    if (data.type === "user") {
+      const content2 = message.content;
+      if (typeof content2 === "string") {
+        if (content2.trim()) {
+          openIdx = -1;
+          turns.push({
+            resumed: false,
+            key: nextKey(record.id),
+            role: "user",
+            nodes: [
+              { key: nextKey(record.id), kind: "user", text: content2.trim() }
+            ],
+            startedAt: record.created_at,
+            completedAt: record.created_at,
+            durationMs: null,
+            costUsd: null,
+            tokens: null
+          });
+        }
+        continue;
+      }
+      if (!Array.isArray(content2)) continue;
+      for (const block of content2) {
+        if (block.type !== "tool_result") continue;
+        const body = toolResultText2(block) || "(no output)";
+        const useId = block.tool_use_id ?? void 0;
+        const node = useId != null ? toolNodeByUseId.get(useId) : void 0;
+        if (node) {
+          node.result = body;
+          node.isError = !!block.is_error;
+        } else {
+          const orphan = {
+            key: nextKey(record.id),
+            kind: "tool",
+            name: "tool",
+            input: null,
+            summary: "",
+            result: body,
+            isError: !!block.is_error
+          };
+          openAgentTurn(record).nodes.push(orphan);
+          if (useId != null) toolNodeByUseId.set(useId, orphan);
+        }
+      }
+      continue;
+    }
+    const content = message.content;
+    if (!Array.isArray(content)) continue;
+    const turn = openAgentTurn(record);
+    const usage = message.usage;
+    if (usage && typeof usage.output_tokens === "number") {
+      turn.tokens = (turn.tokens ?? 0) + usage.output_tokens;
+    }
+    for (const block of content) {
+      if ((block.type === "thinking" || block.type === "redacted_thinking") && typeof block.thinking === "string" && block.thinking.trim()) {
+        turn.nodes.push({
+          key: nextKey(record.id),
+          kind: "thinking",
+          text: block.thinking.trim()
+        });
+      } else if (block.type != null && TOOL_USE_BLOCK_TYPES.has(block.type)) {
+        const name = block.name ?? "tool";
+        const node = {
+          key: nextKey(record.id),
+          kind: "tool",
+          name,
+          input: block.input ?? null,
+          summary: summarizeToolInput(name, block.input ?? void 0),
+          result: null,
+          isError: false
+        };
+        turn.nodes.push(node);
+        if (block.id) toolNodeByUseId.set(block.id, node);
+      } else if (block.type === "text" && typeof block.text === "string" && block.text.trim()) {
+        turn.nodes.push({
+          key: nextKey(record.id),
+          kind: "assistant",
+          text: block.text.trim()
+        });
+      }
+    }
+  }
+  return turns;
+}
+
+// src/store/index.ts
+var TERMINAL_SESSION_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "error",
+  "cancelled",
+  "stopped"
+]);
+function isConversationOver(session) {
+  if (session.session_state != null) {
+    return session.session_state === "closed";
+  }
+  return TERMINAL_SESSION_STATUSES.has(session.status);
+}
+var EMPTY_SNAPSHOT = {
+  session: null,
+  records: [],
+  messages: [],
+  acknowledgedMessageIds: /* @__PURE__ */ new Set(),
+  historyTruncated: false,
+  liveText: "",
+  liveOutputTokens: null,
+  lastEventAt: null,
+  conversationOver: false
+};
+function emptySessionTranscriptSnapshot() {
+  return EMPTY_SNAPSHOT;
+}
+var SessionTranscriptStore = class {
+  snapshot = EMPTY_SNAPSHOT;
+  listeners = /* @__PURE__ */ new Set();
+  acknowledged = /* @__PURE__ */ new Set();
+  // The resume cursor: the highest feed_seq received via records_append. Only
+  // records advance it (§3.4) — 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;
+  // Derived-turn cache, keyed on the records array identity.
+  turnsFor = null;
+  turnsCache = [];
+  get cursor() {
+    return this.cursorSeq;
+  }
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  getSnapshot = () => this.snapshot;
+  // The chat-turn grouping of the current record log (memoized per
+  // records_append batch) — what a chat-style transcript renders.
+  chatTurns = () => {
+    const records = this.snapshot.records;
+    if (this.turnsFor !== records) {
+      this.turnsCache = groupRecordsToChatTurns(records);
+      this.turnsFor = records;
+    }
+    return this.turnsCache;
+  };
+  // Ingest one frame from the stream client. Unknown frame types stamp
+  // liveness and change nothing else (§3.6).
+  ingest = (rawFrame) => {
+    const prev = this.snapshot;
+    const next = {
+      ...prev,
+      lastEventAt: Date.now()
+    };
+    const frame = rawFrame;
+    switch (frame.type) {
+      case "snapshot": {
+        next.session = frame.session;
+        next.messages = frame.messages;
+        for (const message of frame.messages) this.acknowledged.add(message.id);
+        next.acknowledgedMessageIds = new Set(this.acknowledged);
+        next.conversationOver = isConversationOver(frame.session);
+        next.historyTruncated = frame.earliest_feed_seq != null && this.cursorSeq < frame.earliest_feed_seq - 1;
+        break;
+      }
+      case "records_append": {
+        const fresh = frame.records.filter((r) => r.feed_seq > this.cursorSeq);
+        if (fresh.length === 0) break;
+        this.cursorSeq = fresh[fresh.length - 1].feed_seq;
+        next.records = [...prev.records, ...fresh];
+        let acknowledgedNew = false;
+        for (const record of fresh) {
+          if (record.session_message_id != null) {
+            this.acknowledged.add(record.session_message_id);
+            acknowledgedNew = true;
+          }
+        }
+        if (acknowledgedNew) {
+          next.acknowledgedMessageIds = new Set(this.acknowledged);
+        }
+        next.liveText = "";
+        next.liveOutputTokens = null;
+        break;
+      }
+      case "messages": {
+        next.messages = frame.messages;
+        for (const message of frame.messages) this.acknowledged.add(message.id);
+        next.acknowledgedMessageIds = new Set(this.acknowledged);
+        break;
+      }
+      case "session": {
+        next.session = frame.session;
+        next.conversationOver = isConversationOver(frame.session);
+        break;
+      }
+      case "delta": {
+        if (frame.kind !== "text") break;
+        if (frame.text != null) next.liveText = prev.liveText + frame.text;
+        if (frame.output_tokens != null)
+          next.liveOutputTokens = frame.output_tokens;
+        break;
+      }
+      case "done": {
+        next.conversationOver = true;
+        break;
+      }
+      default:
+        break;
+    }
+    this.snapshot = next;
+    for (const listener of this.listeners) listener();
+  };
+};
+export {
+  LineBuffer,
+  SessionTranscriptStore,
+  clampLines,
+  collapseToolRuns,
+  emptySessionTranscriptSnapshot,
+  eventToItems,
+  foldCosts,
+  formatDuration,
+  groupRecordsToChatTurns,
+  isConnectVisibleRecord,
+  isConversationOver,
+  lifecycleText,
+  oneLine,
+  parseEventLine,
+  pendingToolCalls,
+  recordToItems,
+  resultCostUsd,
+  setupOutputHook,
+  setupOutputLine,
+  statusActivityText,
+  summarizeToolInput
+};

package/dist/stream/index.d.ts

@@ -0,0 +1,64 @@
+import { w as StreamFrame, A as AgentSessionWire } from '../types-BRE4NMnS.js';
+
+declare const SESSION_STREAM_PROTOCOL_VERSION = 2;
+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;
+declare function sessionStatusWord(session: AgentSessionWire): string;
+type StreamOutcome = {
+    type: 'done';
+    status: string;
+    exitStatus: string | null;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'aborted';
+};
+declare class StreamUnavailableError extends Error {
+    constructor(message: string);
+}
+declare class StreamAuthError extends Error {
+    constructor(message: string);
+}
+interface StreamSocket {
+    onOpen(cb: () => void): void;
+    onMessage(cb: (data: string) => void): void;
+    onClose(cb: (code: number) => void): void;
+    onError(cb: (err: Error) => void): void;
+    close(): void;
+}
+type OpenSocket = (args: {
+    sessionId: string;
+    afterSeq: number;
+    query: string;
+}) => StreamSocket | Promise<StreamSocket>;
+declare function streamQuery(afterSeq: number): string;
+type CloseKind = 'normal' | 'auth' | 'unsupported' | 'retry';
+declare function classifyCloseCode(code: number): CloseKind;
+declare function nextReconnectDelayMs(attempt: number): number;
+interface ReconnectDecision {
+    action: 'reconnect' | 'fallback' | 'fail-auth';
+    delayMs?: number;
+}
+declare function decideReconnect(params: {
+    closeKind?: CloseKind;
+    everReceivedFrame: boolean;
+    attempt: number;
+    maxReconnects: number;
+}): ReconnectDecision;
+interface StreamSessionOptions {
+    sessionId: string;
+    openSocket: OpenSocket;
+    onFrame: (frame: StreamFrame) => void;
+    afterSeq?: number;
+    signal?: AbortSignal;
+    maxReconnects?: number;
+}
+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 };