@ellipsis-dev/sdk 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { A as AgentSessionWire, L as ListSessionRecordsResponse, a as ListSessionTurnsResponse, S as SessionMessageWire } from './types-BRE4NMnS.js';
-export { b as AgentSessionExitStatus, c as AgentSessionPr, d as AgentSessionSource, e as AgentSessionStatus, f as AgentTurn, g as AgentTurnStatus, h as AttributionType, B as BudgetSource, D as DefaultResolution, i as DeltaFrame, j as DoneFrame, E as ErrorFrame, G as GithubAccountSnippet, k as GithubAccountType, H as Harness, l as HeartbeatFrame, M as MessagesFrame, m as ModelTokensInfo, P as ParentKind, R as RecordsAppendFrame, n as SendSessionMessageRequest, o as SessionFrame, p as SessionLiveness, q as SessionMessageStatus, r as SessionRecordWire, s as SessionState, t as SessionStreamFrame, u as SessionSurface, v as SnapshotFrame, w as StreamFrame, T as TokensInfo, x as TurnTokensInfo, y as components, z as paths } from './types-BRE4NMnS.js';
+import { A as AgentSessionWire, L as ListSessionRecordsResponse, a as ListSessionTurnsResponse, S as SessionMessageWire } from './types-F94JllmC.js';
+export { b as AgentSessionExitStatus, c as AgentSessionPr, d as AgentSessionSource, e as AgentSessionStatus, f as AgentTurn, g as AgentTurnStatus, h as AttributionType, B as BudgetSource, D as DefaultResolution, i as DeltaFrame, j as DoneFrame, E as ErrorFrame, G as GithubAccountSnippet, k as GithubAccountType, H as Harness, l as HeartbeatFrame, M as ModelTokensInfo, P as ParentKind, R as RecordsAppendFrame, m as SendSessionMessageRequest, n as SessionFrame, o as SessionLiveness, p as SessionMessageStatus, q as SessionRecordWire, r as SessionState, s as SessionStreamFrame, t as SessionSurface, u as SnapshotFrame, v as StreamFrame, T as TokensInfo, w as TurnTokensInfo, x as components, y as paths } from './types-F94JllmC.js';
 
 type FetchJson = (path: string, init?: {
     method?: string;

package/dist/store/index.d.ts

@@ -1,4 +1,4 @@
-import { r as SessionRecordWire, A as AgentSessionWire, S as SessionMessageWire, w as StreamFrame } from '../types-BRE4NMnS.js';
+import { q as SessionRecordWire, A as AgentSessionWire, S as SessionMessageWire, v as StreamFrame } from '../types-F94JllmC.js';
 
 interface ChatToolNode {
     key: string;
@@ -8,6 +8,8 @@ interface ChatToolNode {
     summary: string;
     result: string | null;
     isError: boolean;
+    startedAt: string | null;
+    completedAt: string | null;
 }
 type ChatNode = {
     key: string;
@@ -26,7 +28,9 @@ type ChatNode = {
     kind: 'lifecycle';
     text: string;
     recordType: string;
-    hook?: string;
+    step?: string;
+    lines?: string[];
+    payload?: Record<string, unknown>;
 } | ChatToolNode;
 interface ChatTurn {
     key: string;
@@ -41,8 +45,11 @@ interface ChatTurn {
 }
 declare function groupRecordsToChatTurns(records: readonly SessionRecordWire[]): ChatTurn[];
 
-declare function setupOutputHook(payload: Record<string, unknown>): string;
-declare function setupOutputLine(payload: Record<string, unknown>): string | null;
+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;
+declare function cacheTierLabel(tier: unknown): string | null;
+declare function sandboxPhaseLabel(phase: unknown): string;
 declare function lifecycleText(recordType: string, payload: Record<string, unknown>): string | null;
 
 interface CCContentBlock {
@@ -132,6 +139,7 @@ declare class SessionTranscriptStore {
     private snapshot;
     private listeners;
     private acknowledged;
+    private inbox;
     private cursorSeq;
     private turnsFor;
     private turnsCache;
@@ -139,7 +147,9 @@ declare class SessionTranscriptStore {
     subscribe: (listener: () => void) => (() => void);
     getSnapshot: () => SessionTranscriptSnapshot;
     chatTurns: () => ChatTurn[];
+    private pendingMessages;
+    private applyMessageRecord;
     ingest: (rawFrame: StreamFrame) => void;
 }
 
-export { type CCContentBlock, type CCEvent, type ChatNode, type ChatToolNode, type ChatTurn, type EventToItemsOptions, type ItemKind, LineBuffer, type SessionTranscriptSnapshot, SessionTranscriptStore, StreamFrame, type TranscriptItem, clampLines, collapseToolRuns, emptySessionTranscriptSnapshot, eventToItems, foldCosts, formatDuration, groupRecordsToChatTurns, isConnectVisibleRecord, isConversationOver, lifecycleText, oneLine, parseEventLine, pendingToolCalls, recordToItems, resultCostUsd, setupOutputHook, setupOutputLine, statusActivityText, summarizeToolInput };
+export { type CCContentBlock, type CCEvent, type ChatNode, type ChatToolNode, type ChatTurn, type EventToItemsOptions, type ItemKind, LineBuffer, type SessionTranscriptSnapshot, SessionTranscriptStore, StreamFrame, type TranscriptItem, cacheTierLabel, clampLines, collapseToolRuns, emptySessionTranscriptSnapshot, eventToItems, foldCosts, formatDuration, groupRecordsToChatTurns, isConnectVisibleRecord, isConversationOver, lifecycleText, oneLine, parseEventLine, pendingToolCalls, recordToItems, resultCostUsd, sandboxOutputLine, sandboxOutputLines, sandboxOutputStep, sandboxPhaseLabel, statusActivityText, summarizeToolInput };

package/dist/store/index.js

@@ -1,11 +1,15 @@
 // src/store/lifecycle.ts
-function setupOutputHook(payload) {
-  return typeof payload.hook === "string" ? payload.hook : "setup";
+function sandboxOutputStep(payload) {
+  if (typeof payload.step === "string" && payload.step) return payload.step;
+  return typeof payload.phase === "string" ? payload.phase : "setup";
 }
-function setupOutputLine(payload) {
-  const lines = Array.isArray(payload.lines) ? payload.lines.filter(
+function sandboxOutputLines(payload) {
+  return Array.isArray(payload.lines) ? payload.lines.filter(
     (l) => typeof l === "string" && l.trim().length > 0
   ) : [];
+}
+function sandboxOutputLine(payload) {
+  const lines = sandboxOutputLines(payload);
   return lines.length ? lines[lines.length - 1].trim() : null;
 }
 function cacheTierLabel(tier) {
@@ -20,13 +24,71 @@ function cacheTierLabel(tier) {
       return null;
   }
 }
+function sandboxPhaseLabel(phase) {
+  switch (phase) {
+    case "image":
+      return "Preparing image";
+    case "clone":
+      return "Fetching repositories";
+    case "setup":
+      return "Running setup";
+    case "snapshot":
+      return "Snapshotting";
+    case "hooks":
+      return "Running hooks";
+    case "restore":
+      return "Restoring workspace";
+    default:
+      return typeof phase === "string" && phase ? phase.charAt(0).toUpperCase() + phase.slice(1) : "Working";
+  }
+}
+function durationLabel(ms) {
+  if (typeof ms !== "number" || !isFinite(ms) || ms < 0) return null;
+  return ms >= 1e3 ? `${(ms / 1e3).toFixed(1)}s` : `${Math.round(ms)}ms`;
+}
+function sandboxPhaseText(payload) {
+  const label = sandboxPhaseLabel(payload.phase);
+  const detail = payload.detail && typeof payload.detail === "object" ? payload.detail : {};
+  switch (payload.status) {
+    case "started":
+      return `${label}\u2026`;
+    case "completed": {
+      const parts = [label];
+      const tier = cacheTierLabel(detail.cache_tier);
+      if (tier) parts.push(tier);
+      const duration = durationLabel(payload.duration_ms);
+      if (duration) parts.push(duration);
+      return parts.join(" \xB7 ");
+    }
+    case "failed": {
+      const duration = durationLabel(payload.duration_ms);
+      return duration ? `${label} failed \xB7 ${duration}` : `${label} failed`;
+    }
+    default:
+      return label;
+  }
+}
 function lifecycleText(recordType, payload) {
   switch (recordType) {
+    case "session_scheduled": {
+      const config = typeof payload.config_name === "string" ? payload.config_name : null;
+      return config ? `Session scheduled \xB7 ${config}` : "Session scheduled";
+    }
+    case "session_starting": {
+      const attempt = typeof payload.attempt === "number" ? payload.attempt : 0;
+      if (attempt > 0) return "Retrying\u2026";
+      const wakeIndex = typeof payload.wake_index === "number" ? payload.wake_index : 0;
+      return wakeIndex > 0 ? "Waking the session\u2026" : "Session starting\u2026";
+    }
+    case "session_retrying":
+      return typeof payload.reason === "string" && payload.reason ? `Retrying \xB7 ${payload.reason}` : "Retrying after a transient error\u2026";
     case "sandbox_starting":
       return "Starting sandbox\u2026";
-    case "sandbox_setup_output": {
-      const last = setupOutputLine(payload);
-      return last ? `${setupOutputHook(payload)} \xB7 ${last}` : null;
+    case "sandbox_phase":
+      return sandboxPhaseText(payload);
+    case "sandbox_output": {
+      const last = sandboxOutputLine(payload);
+      return last ? `${sandboxOutputStep(payload)} \xB7 ${last}` : null;
     }
     case "sandbox_ready": {
       const repos = Array.isArray(payload.repositories) ? payload.repositories.filter(
@@ -40,8 +102,8 @@ function lifecycleText(recordType, payload) {
     }
     case "session_resumed":
       return "Resumed the conversation";
-    case "session_paused":
-      return "Sleeping \u2014 your next message wakes it";
+    case "session_idle":
+      return "Idle \u2014 your next message wakes it";
     case "session_closed":
       return "Conversation closed";
     case "session_cancelled": {
@@ -314,6 +376,12 @@ var TOOL_USE_BLOCK_TYPES = /* @__PURE__ */ new Set([
   "server_tool_use",
   "mcp_tool_use"
 ]);
+var SANDBOX_RECORD_TYPES = /* @__PURE__ */ new Set([
+  "sandbox_starting",
+  "sandbox_phase",
+  "sandbox_output",
+  "sandbox_ready"
+]);
 function toolResultText2(block) {
   const c = block.content;
   if (typeof c === "string") return c.trim();
@@ -331,6 +399,7 @@ function groupRecordsToChatTurns(records) {
   let seq = 0;
   const nextKey = (base) => `${base}:${seq++}`;
   let openIdx = -1;
+  let prevCumulativeCostUsd = 0;
   let initCount = 0;
   let pendingResume = false;
   const openAgentTurn = (record) => {
@@ -354,36 +423,64 @@ function groupRecordsToChatTurns(records) {
   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;
+      if (!text) continue;
+      const isSandbox = SANDBOX_RECORD_TYPES.has(record.record_type);
+      const isSandboxOutput = record.record_type === "sandbox_output";
+      const step = isSandboxOutput ? sandboxOutputStep(record.payload) : void 0;
+      const lines = isSandboxOutput ? sandboxOutputLines(record.payload) : void 0;
+      let foldTarget = null;
+      if (isSandbox && record.record_type !== "sandbox_starting") {
+        for (let i = turns.length - 1; i >= 0; i--) {
+          const candidate = turns[i];
+          if (candidate.role !== "lifecycle") break;
+          if (candidate.nodes.some(
+            (n) => n.kind === "lifecycle" && SANDBOX_RECORD_TYPES.has(n.recordType)
+          )) {
+            foldTarget = candidate;
+            break;
+          }
         }
-        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
-        });
       }
+      if (foldTarget) {
+        const last = foldTarget.nodes[foldTarget.nodes.length - 1];
+        if (isSandboxOutput && last && last.kind === "lifecycle" && last.recordType === "sandbox_output" && last.step === step) {
+          last.text = text;
+          last.lines = [...last.lines ?? [], ...lines ?? []];
+        } else {
+          foldTarget.nodes.push({
+            key: nextKey(record.id),
+            kind: "lifecycle",
+            text,
+            recordType: record.record_type,
+            step,
+            lines,
+            payload: record.payload
+          });
+        }
+        foldTarget.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,
+            step,
+            lines,
+            payload: record.payload
+          }
+        ],
+        startedAt: record.created_at,
+        completedAt: record.created_at,
+        durationMs: null,
+        costUsd: null,
+        tokens: null,
+        resumed: false
+      });
       continue;
     }
     if (record.source !== "claude_code") continue;
@@ -399,8 +496,13 @@ function groupRecordsToChatTurns(records) {
       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;
+        if (typeof data.total_cost_usd === "number") {
+          turns[openIdx].costUsd = Math.max(
+            0,
+            data.total_cost_usd - prevCumulativeCostUsd
+          );
+          prevCumulativeCostUsd = data.total_cost_usd;
+        }
         openIdx = -1;
       }
       continue;
@@ -437,6 +539,7 @@ function groupRecordsToChatTurns(records) {
         if (node) {
           node.result = body;
           node.isError = !!block.is_error;
+          node.completedAt = record.created_at;
         } else {
           const orphan = {
             key: nextKey(record.id),
@@ -445,7 +548,9 @@ function groupRecordsToChatTurns(records) {
             input: null,
             summary: "",
             result: body,
-            isError: !!block.is_error
+            isError: !!block.is_error,
+            startedAt: null,
+            completedAt: record.created_at
           };
           openAgentTurn(record).nodes.push(orphan);
           if (useId != null) toolNodeByUseId.set(useId, orphan);
@@ -476,7 +581,9 @@ function groupRecordsToChatTurns(records) {
           input: block.input ?? null,
           summary: summarizeToolInput(name, block.input ?? void 0),
           result: null,
-          isError: false
+          isError: false,
+          startedAt: record.created_at,
+          completedAt: null
         };
         turn.nodes.push(node);
         if (block.id) toolNodeByUseId.set(block.id, node);
@@ -523,6 +630,11 @@ var SessionTranscriptStore = class {
   snapshot = EMPTY_SNAPSHOT;
   listeners = /* @__PURE__ */ new Set();
   acknowledged = /* @__PURE__ */ new Set();
+  // The inbox projection (protocol v3): 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
   // tracks its own copy; this one seeds a NEW streamSession call (e.g. a
@@ -551,6 +663,57 @@ var SessionTranscriptStore = class {
     }
     return this.turnsCache;
   };
+  // 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).
+  applyMessageRecord = (record) => {
+    const payload = record.payload;
+    const messageId = typeof payload.message_id === "string" ? payload.message_id : null;
+    switch (record.record_type) {
+      case "message_received": {
+        if (messageId == null || this.inbox.has(messageId)) return false;
+        this.inbox.set(messageId, {
+          id: messageId,
+          agent_session_id: record.agent_session_id,
+          feed_seq: record.feed_seq,
+          status: "pending",
+          body: typeof payload.body === "string" ? payload.body : "",
+          author: typeof payload.author === "string" ? payload.author : null,
+          sender_attribution_type: typeof payload.sender_attribution_type === "string" ? payload.sender_attribution_type : null,
+          sender_attribution_id: typeof payload.sender_attribution_id === "string" ? payload.sender_attribution_id : null,
+          created_at: record.created_at,
+          delivered_at: null,
+          delivered_turn_id: null
+        });
+        return true;
+      }
+      case "message_delivered": {
+        const existing = messageId != null ? this.inbox.get(messageId) : null;
+        if (!existing || existing.status !== "pending") return false;
+        this.inbox.set(messageId, {
+          ...existing,
+          status: "delivered",
+          delivered_at: record.created_at,
+          delivered_turn_id: typeof payload.turn_id === "string" ? payload.turn_id : null
+        });
+        return true;
+      }
+      case "message_requeued": {
+        const existing = messageId != null ? this.inbox.get(messageId) : null;
+        if (!existing || existing.status === "pending") return false;
+        this.inbox.set(messageId, {
+          ...existing,
+          status: "pending",
+          delivered_at: null,
+          delivered_turn_id: null
+        });
+        return true;
+      }
+      default:
+        return false;
+    }
+  };
   // Ingest one frame from the stream client. Unknown frame types stamp
   // liveness and change nothing else (§3.6).
   ingest = (rawFrame) => {
@@ -563,8 +726,11 @@ var SessionTranscriptStore = class {
     switch (frame.type) {
       case "snapshot": {
         next.session = frame.session;
-        next.messages = frame.messages;
-        for (const message of frame.messages) this.acknowledged.add(message.id);
+        for (const message of frame.messages) {
+          this.inbox.set(message.id, message);
+          this.acknowledged.add(message.id);
+        }
+        next.messages = this.pendingMessages();
         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;
@@ -576,12 +742,24 @@ var SessionTranscriptStore = class {
         this.cursorSeq = fresh[fresh.length - 1].feed_seq;
         next.records = [...prev.records, ...fresh];
         let acknowledgedNew = false;
+        let inboxChanged = false;
         for (const record of fresh) {
           if (record.session_message_id != null) {
             this.acknowledged.add(record.session_message_id);
             acknowledgedNew = true;
           }
+          if (record.source === "lifecycle") {
+            inboxChanged = this.applyMessageRecord(record) || inboxChanged;
+            if (record.record_type === "message_received" || record.record_type === "message_delivered") {
+              const payload = record.payload;
+              if (typeof payload.message_id === "string") {
+                this.acknowledged.add(payload.message_id);
+                acknowledgedNew = true;
+              }
+            }
+          }
         }
+        if (inboxChanged) next.messages = this.pendingMessages();
         if (acknowledgedNew) {
           next.acknowledgedMessageIds = new Set(this.acknowledged);
         }
@@ -589,12 +767,6 @@ var SessionTranscriptStore = class {
         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);
@@ -621,6 +793,7 @@ var SessionTranscriptStore = class {
 export {
   LineBuffer,
   SessionTranscriptStore,
+  cacheTierLabel,
   clampLines,
   collapseToolRuns,
   emptySessionTranscriptSnapshot,
@@ -636,8 +809,10 @@ export {
   pendingToolCalls,
   recordToItems,
   resultCostUsd,
-  setupOutputHook,
-  setupOutputLine,
+  sandboxOutputLine,
+  sandboxOutputLines,
+  sandboxOutputStep,
+  sandboxPhaseLabel,
   statusActivityText,
   summarizeToolInput
 };

package/dist/stream/index.d.ts

@@ -1,6 +1,6 @@
-import { w as StreamFrame, A as AgentSessionWire } from '../types-BRE4NMnS.js';
+import { v as StreamFrame, A as AgentSessionWire } from '../types-F94JllmC.js';
 
-declare const SESSION_STREAM_PROTOCOL_VERSION = 2;
+declare const SESSION_STREAM_PROTOCOL_VERSION = 3;
 declare const WS_CLOSE_NORMAL = 1000;
 declare const WS_CLOSE_GOING_AWAY = 1001;
 declare const WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION = 1002;

package/dist/stream/index.js

@@ -1,5 +1,5 @@
 // src/stream/index.ts
-var SESSION_STREAM_PROTOCOL_VERSION = 2;
+var SESSION_STREAM_PROTOCOL_VERSION = 3;
 var WS_CLOSE_NORMAL = 1e3;
 var WS_CLOSE_GOING_AWAY = 1001;
 var WS_CLOSE_UNSUPPORTED_PROTOCOL_VERSION = 1002;

package/dist/{types-BRE4NMnS.d.ts → types-F94JllmC.d.ts}

@@ -876,9 +876,9 @@ interface operations {
 }
 
 /**
- * One server-to-client frame of the Ellipsis session stream protocol v2 (WS /v1/sessions/{id}/stream?protocol=2). Clients MUST ignore frames with unknown `type` values — additive frames are not a protocol break.
+ * One server-to-client frame of the Ellipsis session stream protocol v3 (WS /v1/sessions/{id}/stream?protocol=3). Clients MUST ignore frames with unknown `type` values — additive frames are not a protocol break.
  */
-type SessionStreamFrame = SnapshotFrame | RecordsAppendFrame | MessagesFrame | SessionFrame | DeltaFrame | HeartbeatFrame | DoneFrame | ErrorFrame;
+type SessionStreamFrame = SnapshotFrame | RecordsAppendFrame | SessionFrame | DeltaFrame | HeartbeatFrame | DoneFrame | ErrorFrame;
 type AttributionType = 'github_user' | 'linear_user' | 'slack_user' | 'api_key';
 type SessionMessageStatus = 'pending' | 'delivered';
 type GithubAccountType = 'User' | 'Organization' | 'Bot' | 'Mannequin';
@@ -1123,17 +1123,6 @@ interface TurnTokensInfo {
     input_tokens: number;
     output_tokens: number;
 }
-/**
- * LWW snapshot of the OPEN inbox slice: all PENDING rows plus rows that
- * flipped (delivered, re-pended) within this connection since the last frame.
- * Deliberately not the full message history — delivered rows render through
- * their transcript user-echo records; structural history stays on REST
- * /turns (§3.3).
- */
-interface MessagesFrame {
-    messages: SessionMessageWire[];
-    type: 'messages';
-}
 /**
  * LWW snapshot of the enriched public session (§4.1) — the only way
  * status/state/cost arrive. Resent whole on any field change.
@@ -1189,4 +1178,4 @@ type ListSessionTurnsResponse = components['schemas']['ListSessionTurnsResponse'
 type AgentTurn = components['schemas']['AgentTurn'];
 type AgentTurnStatus = components['schemas']['AgentTurnStatus'];
 
-export type { AgentSessionWire as A, BudgetSource as B, DefaultResolution as D, ErrorFrame as E, GithubAccountSnippet as G, Harness as H, ListSessionRecordsResponse as L, MessagesFrame as M, ParentKind as P, RecordsAppendFrame as R, SessionMessageWire as S, TokensInfo as T, ListSessionTurnsResponse as a, AgentSessionExitStatus as b, AgentSessionPr as c, AgentSessionSource as d, AgentSessionStatus as e, AgentTurn as f, AgentTurnStatus as g, AttributionType as h, DeltaFrame as i, DoneFrame as j, GithubAccountType as k, HeartbeatFrame as l, ModelTokensInfo as m, SendSessionMessageRequest as n, SessionFrame as o, SessionLiveness as p, SessionMessageStatus as q, SessionRecordWire as r, SessionState as s, SessionStreamFrame as t, SessionSurface as u, SnapshotFrame as v, StreamFrame as w, TurnTokensInfo as x, components as y, paths as z };
+export type { AgentSessionWire as A, BudgetSource as B, DefaultResolution as D, ErrorFrame as E, GithubAccountSnippet as G, Harness as H, ListSessionRecordsResponse as L, ModelTokensInfo as M, ParentKind as P, RecordsAppendFrame as R, SessionMessageWire as S, TokensInfo as T, ListSessionTurnsResponse as a, AgentSessionExitStatus as b, AgentSessionPr as c, AgentSessionSource as d, AgentSessionStatus as e, AgentTurn as f, AgentTurnStatus as g, AttributionType as h, DeltaFrame as i, DoneFrame as j, GithubAccountType as k, HeartbeatFrame as l, SendSessionMessageRequest as m, SessionFrame as n, SessionLiveness as o, SessionMessageStatus as p, SessionRecordWire as q, SessionState as r, SessionStreamFrame as s, SessionSurface as t, SnapshotFrame as u, StreamFrame as v, TurnTokensInfo as w, components as x, paths as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ellipsis-dev/sdk",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "TypeScript SDK for the Ellipsis agents platform: /v1 REST types + client, the session stream WebSocket client, and the session transcript store.",
   "license": "MIT",
   "type": "module",

package/schema/frames.schema.json

@@ -757,30 +757,6 @@
       "title": "HeartbeatFrame",
       "type": "object"
     },
-    "MessagesFrame": {
-      "description": "LWW snapshot of the OPEN inbox slice: all PENDING rows plus rows that\nflipped (delivered, re-pended) within this connection since the last frame.\nDeliberately not the full message history \u2014 delivered rows render through\ntheir transcript user-echo records; structural history stays on REST\n/turns (\u00a73.3).",
-      "properties": {
-        "messages": {
-          "items": {
-            "$ref": "#/$defs/SessionMessageWire"
-          },
-          "title": "Messages",
-          "type": "array"
-        },
-        "type": {
-          "const": "messages",
-          "default": "messages",
-          "title": "Type",
-          "type": "string"
-        }
-      },
-      "required": [
-        "messages",
-        "type"
-      ],
-      "title": "MessagesFrame",
-      "type": "object"
-    },
     "ModelTokensInfo": {
       "properties": {
         "cache_creation_input_tokens": {
@@ -1243,7 +1219,7 @@
           "type": "array"
         },
         "protocol": {
-          "default": 2,
+          "default": 3,
           "title": "Protocol",
           "type": "integer"
         },
@@ -1396,7 +1372,7 @@
     }
   },
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "description": "One server-to-client frame of the Ellipsis session stream protocol v2 (WS /v1/sessions/{id}/stream?protocol=2). Clients MUST ignore frames with unknown `type` values \u2014 additive frames are not a protocol break.",
+  "description": "One server-to-client frame of the Ellipsis session stream protocol v3 (WS /v1/sessions/{id}/stream?protocol=3). Clients MUST ignore frames with unknown `type` values \u2014 additive frames are not a protocol break.",
   "oneOf": [
     {
       "$ref": "#/$defs/SnapshotFrame"
@@ -1404,9 +1380,6 @@
     {
       "$ref": "#/$defs/RecordsAppendFrame"
     },
-    {
-      "$ref": "#/$defs/MessagesFrame"
-    },
     {
       "$ref": "#/$defs/SessionFrame"
     },

package/schema/lifecycle.schema.json

@@ -0,0 +1,505 @@
+{
+  "$defs": {
+    "MessageDeliveredPayload": {
+      "description": "message_delivered \u2014 a turn consumed the message.",
+      "properties": {
+        "message_id": {
+          "title": "Message Id",
+          "type": "string"
+        },
+        "turn_id": {
+          "title": "Turn Id",
+          "type": "string"
+        }
+      },
+      "required": [
+        "message_id",
+        "turn_id"
+      ],
+      "title": "MessageDeliveredPayload",
+      "type": "object"
+    },
+    "MessageReceivedPayload": {
+      "description": "message_received \u2014 a message landed in the session inbox. Puts \"what\narrived, from whom, when\" in the downloadable log; the session_messages\nrow is the internal delivery projection.",
+      "properties": {
+        "author": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Author"
+        },
+        "body": {
+          "title": "Body",
+          "type": "string"
+        },
+        "closes_session": {
+          "default": false,
+          "title": "Closes Session",
+          "type": "boolean"
+        },
+        "message_id": {
+          "title": "Message Id",
+          "type": "string"
+        },
+        "sender_attribution_id": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Sender Attribution Id"
+        },
+        "sender_attribution_type": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Sender Attribution Type"
+        }
+      },
+      "required": [
+        "message_id",
+        "body"
+      ],
+      "title": "MessageReceivedPayload",
+      "type": "object"
+    },
+    "MessageRequeuedPayload": {
+      "description": "message_requeued \u2014 an errored turn returned the message to the inbox\n(at-least-once delivery; the next wake redelivers).",
+      "properties": {
+        "message_id": {
+          "title": "Message Id",
+          "type": "string"
+        },
+        "turn_id": {
+          "title": "Turn Id",
+          "type": "string"
+        }
+      },
+      "required": [
+        "message_id",
+        "turn_id"
+      ],
+      "title": "MessageRequeuedPayload",
+      "type": "object"
+    },
+    "SandboxOutputPayload": {
+      "description": "sandbox_output \u2014 one chunk of provisioning/lifecycle-script output.\nMany fire per execution; `chunk` rides the idempotency key. These records\nARE the durable copy (archived into the session log's S3 segments), under\na high per-session cap + truncation marker.",
+      "properties": {
+        "chunk": {
+          "title": "Chunk",
+          "type": "integer"
+        },
+        "lines": {
+          "items": {
+            "type": "string"
+          },
+          "title": "Lines",
+          "type": "array"
+        },
+        "phase": {
+          "title": "Phase",
+          "type": "string"
+        },
+        "step": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Step"
+        },
+        "stream": {
+          "default": "stdout",
+          "title": "Stream",
+          "type": "string"
+        }
+      },
+      "required": [
+        "phase",
+        "chunk",
+        "lines"
+      ],
+      "title": "SandboxOutputPayload",
+      "type": "object"
+    },
+    "SandboxPhasePayload": {
+      "description": "sandbox_phase \u2014 one transition of the provisioning state machine, so\nclients can narrate 'found a cached image' / 'cloning' / 'snapshotting'\nlive and locate failures. Phases are an OPEN vocabulary (SandboxPhase has\nthe known values); `detail` carries phase-specific extras additively\n(e.g. {\"cache_tier\": \"incremental\"} on image completion).",
+      "properties": {
+        "detail": {
+          "anyOf": [
+            {
+              "additionalProperties": true,
+              "type": "object"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Detail"
+        },
+        "duration_ms": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Duration Ms"
+        },
+        "phase": {
+          "title": "Phase",
+          "type": "string"
+        },
+        "status": {
+          "title": "Status",
+          "type": "string"
+        },
+        "step": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Step"
+        }
+      },
+      "required": [
+        "phase",
+        "status"
+      ],
+      "title": "SandboxPhasePayload",
+      "type": "object"
+    },
+    "SandboxReadyPayload": {
+      "description": "sandbox_ready \u2014 the box is up and the harness is about to launch: the\nsummary anchor closing the provisioning story. cache_tier/phase_timings\nduplicate the sandboxes-row columns purely for rendering convenience \u2014 the\nrow is the authority (\u00a72).",
+      "properties": {
+        "cache_tier": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Cache Tier"
+        },
+        "phase_timings": {
+          "additionalProperties": {
+            "type": "number"
+          },
+          "default": {},
+          "title": "Phase Timings",
+          "type": "object"
+        },
+        "repositories": {
+          "items": {
+            "type": "string"
+          },
+          "title": "Repositories",
+          "type": "array"
+        }
+      },
+      "required": [
+        "repositories"
+      ],
+      "title": "SandboxReadyPayload",
+      "type": "object"
+    },
+    "SandboxStartingPayload": {
+      "description": "sandbox_starting \u2014 provisioning begins for this execution.",
+      "properties": {
+        "repositories": {
+          "items": {
+            "type": "string"
+          },
+          "title": "Repositories",
+          "type": "array"
+        }
+      },
+      "required": [
+        "repositories"
+      ],
+      "title": "SandboxStartingPayload",
+      "type": "object"
+    },
+    "SessionCancelledPayload": {
+      "description": "session_cancelled \u2014 a preflight gate cancelled the session before any\nsandbox existed. Session-scoped (no execution).",
+      "properties": {
+        "reason": {
+          "title": "Reason",
+          "type": "string"
+        }
+      },
+      "required": [
+        "reason"
+      ],
+      "title": "SessionCancelledPayload",
+      "type": "object"
+    },
+    "SessionClosedPayload": {
+      "description": "session_closed \u2014 the conversation terminalized (closing event's final\nturn, or an ephemeral session's terminal).",
+      "properties": {},
+      "title": "SessionClosedPayload",
+      "type": "object"
+    },
+    "SessionIdlePayload": {
+      "description": "session_idle \u2014 the warm loop ended and the durable conversation is\nparked; the next message wakes it.",
+      "properties": {},
+      "title": "SessionIdlePayload",
+      "type": "object"
+    },
+    "SessionResumedPayload": {
+      "description": "session_resumed \u2014 a wake mounted the teardown snapshots and --resumed\nthe transcript. Its ABSENCE after a wake is the degraded-wake signal.",
+      "properties": {
+        "wake_index": {
+          "title": "Wake Index",
+          "type": "integer"
+        }
+      },
+      "required": [
+        "wake_index"
+      ],
+      "title": "SessionResumedPayload",
+      "type": "object"
+    },
+    "SessionRetryingPayload": {
+      "description": "session_retrying \u2014 a transient infra failure before the agent acted\nhanded the session back for another attempt (bounded).",
+      "properties": {
+        "attempt": {
+          "title": "Attempt",
+          "type": "integer"
+        },
+        "reason": {
+          "title": "Reason",
+          "type": "string"
+        }
+      },
+      "required": [
+        "reason",
+        "attempt"
+      ],
+      "title": "SessionRetryingPayload",
+      "type": "object"
+    },
+    "SessionScheduledPayload": {
+      "description": "session_scheduled \u2014 the session row exists and is queued for a worker.\nThe one session-scoped record emitted at creation (no execution yet).",
+      "properties": {
+        "config_name": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Config Name"
+        },
+        "source": {
+          "title": "Source",
+          "type": "string"
+        }
+      },
+      "required": [
+        "source"
+      ],
+      "title": "SessionScheduledPayload",
+      "type": "object"
+    },
+    "SessionStartingPayload": {
+      "description": "session_starting \u2014 a worker claimed the session and preflight passed.\nEmitted on EVERY claim; clients render wake_index > 0 as a wake.",
+      "properties": {
+        "attempt": {
+          "title": "Attempt",
+          "type": "integer"
+        },
+        "wake_index": {
+          "title": "Wake Index",
+          "type": "integer"
+        }
+      },
+      "required": [
+        "attempt",
+        "wake_index"
+      ],
+      "title": "SessionStartingPayload",
+      "type": "object"
+    },
+    "TurnCompletedPayload": {
+      "description": "turn_completed \u2014 the turn's result event closed it.",
+      "properties": {
+        "duration_ms": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Duration Ms"
+        },
+        "turn_id": {
+          "title": "Turn Id",
+          "type": "string"
+        },
+        "turn_index": {
+          "title": "Turn Index",
+          "type": "integer"
+        }
+      },
+      "required": [
+        "turn_id",
+        "turn_index"
+      ],
+      "title": "TurnCompletedPayload",
+      "type": "object"
+    },
+    "TurnFailedPayload": {
+      "description": "turn_failed \u2014 the turn terminalized without completing (its consumed\nmessages requeue).",
+      "properties": {
+        "turn_id": {
+          "title": "Turn Id",
+          "type": "string"
+        },
+        "turn_index": {
+          "title": "Turn Index",
+          "type": "integer"
+        }
+      },
+      "required": [
+        "turn_id",
+        "turn_index"
+      ],
+      "title": "TurnFailedPayload",
+      "type": "object"
+    },
+    "TurnStartedPayload": {
+      "description": "turn_started \u2014 a message-exchange began.",
+      "properties": {
+        "turn_id": {
+          "title": "Turn Id",
+          "type": "string"
+        },
+        "turn_index": {
+          "title": "Turn Index",
+          "type": "integer"
+        }
+      },
+      "required": [
+        "turn_id",
+        "turn_index"
+      ],
+      "title": "TurnStartedPayload",
+      "type": "object"
+    }
+  },
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "description": "Payloads of source='lifecycle' session records, keyed by record_type. Contract (SESSION_LIFECYCLE_EVENTS.md \u00a72): payload changes are additive-only; clients MUST ignore unknown record types and unknown payload fields, and MUST render unknown phase/step/status values generically.",
+  "properties": {
+    "message_delivered": {
+      "$ref": "#/$defs/MessageDeliveredPayload"
+    },
+    "message_received": {
+      "$ref": "#/$defs/MessageReceivedPayload"
+    },
+    "message_requeued": {
+      "$ref": "#/$defs/MessageRequeuedPayload"
+    },
+    "sandbox_output": {
+      "$ref": "#/$defs/SandboxOutputPayload"
+    },
+    "sandbox_phase": {
+      "$ref": "#/$defs/SandboxPhasePayload"
+    },
+    "sandbox_ready": {
+      "$ref": "#/$defs/SandboxReadyPayload"
+    },
+    "sandbox_starting": {
+      "$ref": "#/$defs/SandboxStartingPayload"
+    },
+    "session_cancelled": {
+      "$ref": "#/$defs/SessionCancelledPayload"
+    },
+    "session_closed": {
+      "$ref": "#/$defs/SessionClosedPayload"
+    },
+    "session_idle": {
+      "$ref": "#/$defs/SessionIdlePayload"
+    },
+    "session_resumed": {
+      "$ref": "#/$defs/SessionResumedPayload"
+    },
+    "session_retrying": {
+      "$ref": "#/$defs/SessionRetryingPayload"
+    },
+    "session_scheduled": {
+      "$ref": "#/$defs/SessionScheduledPayload"
+    },
+    "session_starting": {
+      "$ref": "#/$defs/SessionStartingPayload"
+    },
+    "turn_completed": {
+      "$ref": "#/$defs/TurnCompletedPayload"
+    },
+    "turn_failed": {
+      "$ref": "#/$defs/TurnFailedPayload"
+    },
+    "turn_started": {
+      "$ref": "#/$defs/TurnStartedPayload"
+    }
+  },
+  "required": [
+    "message_delivered",
+    "message_received",
+    "message_requeued",
+    "sandbox_output",
+    "sandbox_phase",
+    "sandbox_ready",
+    "sandbox_starting",
+    "session_cancelled",
+    "session_closed",
+    "session_idle",
+    "session_resumed",
+    "session_retrying",
+    "session_scheduled",
+    "session_starting",
+    "turn_completed",
+    "turn_failed",
+    "turn_started"
+  ],
+  "title": "LifecyclePayloads",
+  "type": "object"
+}