@ellipsis-dev/sdk 0.35.0 → 0.37.0

package/dist/index.js

@@ -29,14 +29,12 @@ var Page = class {
 };
 
 // src/core/sessionHandle.ts
-var FINAL_TURN_STATUSES = /* @__PURE__ */ new Set([
-  "completed",
-  "failed",
-  "stopped",
-  "cancelled"
+var SETTLED_SESSION_STATUSES = /* @__PURE__ */ new Set([
+  "idle",
+  "closed"
 ]);
-function isTurnFinal(status) {
-  return FINAL_TURN_STATUSES.has(status);
+function isSessionSettled(status) {
+  return SETTLED_SESSION_STATUSES.has(status);
 }
 var DEFAULT_POLL_INTERVAL_MS = 3e3;
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -45,50 +43,55 @@ var SessionHandle = class {
     this.sessions = sessions;
     this.id = session.id;
     this.session = session;
-    this.turnId = session.turn?.id ?? null;
   }
   sessions;
   id;
   // The latest session snapshot this handle saw.
   session;
-  // The turn `wait()` waits on: the session's turn after `run()`, then the
-  // turn each `send()` creates. Null until the session has a message.
-  turnId;
+  // The message `wait()` waits on: the last one sent through `send()`, else
+  // the session's latest message.
+  messageId = null;
   async refresh() {
     this.session = (await this.sessions.get(this.id)).session;
     return this.session;
   }
-  // Poll until the awaited turn reaches a final status (completed, failed,
-  // stopped, cancelled) or the conversation closes, and return that turn.
-  // Returns null at once when the session has no turn to wait on.
+  // Poll until the session is idle or closed, then return how the awaited
+  // message ended: its `message_ended` record's payload. Null when the
+  // session has no message.
   async wait(options = {}) {
     const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     const deadline = options.timeoutMs == null ? null : Date.now() + options.timeoutMs;
     for (; ; ) {
       const session = await this.refresh();
-      const turnId = this.turnId;
-      if (turnId == null) return null;
-      const turn = session.turn?.id === turnId ? session.turn : (await this.sessions.turns.get(this.id, turnId)).turn;
-      if (isTurnFinal(turn.status) || session.conversation.state === "closed")
-        return turn;
+      if (isSessionSettled(session.status)) break;
       if (deadline != null && Date.now() >= deadline) {
         throw new Error(
-          `turn ${turnId} of session ${this.id} not final after ${options.timeoutMs}ms`
+          `session ${this.id} not settled after ${options.timeoutMs}ms`
         );
       }
       await sleep(pollIntervalMs);
     }
+    let ended = null;
+    const page = await this.sessions.records(this.id, {
+      message_id: this.messageId
+    });
+    for await (const record of page) {
+      if (record.kind !== "platform" || record.record_type !== "message_ended")
+        continue;
+      if (this.messageId == null || record.message_id === this.messageId)
+        ended = record.payload;
+    }
+    return ended;
   }
-  // Post a message into the session. The returned turn is the one that will
-  // answer it, and the one `wait()` waits on from now. `images` ride the
-  // message as content blocks the model sees on that turn.
+  // Send a message to the session; `wait()` then waits for it to be
+  // answered. `images` ride the message as content blocks the model sees.
   async send(message, options = {}) {
     const response = await this.sessions.sendMessage(this.id, {
       message,
       images: options.images,
       idempotency_key: options.idempotencyKey
     });
-    this.turnId = response.turn.id;
+    this.messageId = response.message.id;
     return response;
   }
   async stop() {
@@ -1714,58 +1717,11 @@ var EllipsisSecrets = class {
     return await this.transport.request("PUT", path, { body });
   }
 };
-var EllipsisSessionsTurns = class {
-  constructor(transport) {
-    this.transport = transport;
-  }
-  transport;
-  /**
-   * Get Session Turn
-   *
-   * Return one turn.
-   *
-   * Poll this after sending a message: the message is answered when
-   * the turn's status is completed, failed, stopped, or cancelled.
-   *
-   * Required permissions: read:sessions.
-   * API key: Supported.
-   * CLI user token: Supported.
-   * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-   * Higher permission levels include lower levels: read < write < delete.
-   * Grant match patterns can further restrict access to individual resources.
-   */
-  async get(session_id, id) {
-    const path = `/v1/sessions/${enc(session_id)}/turns/${enc(id)}`;
-    return await this.transport.request("GET", path);
-  }
-  /**
-   * Get Session Turns
-   *
-   * Return the session's turns and messages, oldest first.
-   *
-   * One turn per message: pending until the agent starts on it,
-   * running while it works, then completed, failed, stopped, or
-   * cancelled.
-   *
-   * Required permissions: read:sessions.
-   * API key: Supported.
-   * CLI user token: Supported.
-   * Session token: Requires the ellipsis:api scope and the required grants in the token's permissions.ellipsis configuration.
-   * Higher permission levels include lower levels: read < write < delete.
-   * Grant match patterns can further restrict access to individual resources.
-   */
-  async list(id) {
-    const path = `/v1/sessions/${enc(id)}/turns`;
-    return await this.transport.request("GET", path);
-  }
-};
 var EllipsisSessions = class {
   constructor(transport) {
     this.transport = transport;
-    this.turns = new EllipsisSessionsTurns(transport);
   }
   transport;
-  turns;
   /**
    * Get Session Analytics
    *
@@ -1908,8 +1864,7 @@ var EllipsisSessions = class {
    * List cloud agent sessions, newest first.
    *
    * Optionally filtered by agent (id or name), source, service, handler, time
-   * window, attributed author, repository, and whether the session is
-   * still going.
+   * window, attributed author, repository, and status.
    *
    * Required permissions: read:sessions.
    * API key: Supported.
@@ -1920,7 +1875,7 @@ var EllipsisSessions = class {
    */
   async list(options = {}) {
     const path = "/v1/sessions";
-    const query = buildQuery({ agent: options.agent, source: options.source, service: options.service, handler: options.handler, days: options.days, start: options.start, end: options.end, limit: options.limit, cursor: options.cursor, author_id: options.author_id, repo: options.repo, unfinished: options.unfinished });
+    const query = buildQuery({ agent: options.agent, source: options.source, service: options.service, handler: options.handler, days: options.days, start: options.start, end: options.end, limit: options.limit, cursor: options.cursor, author_id: options.author_id, repo: options.repo, status: options.status });
     const response = await this.transport.request("GET", path, { query });
     return new Page(
       response,
@@ -1967,7 +1922,7 @@ var EllipsisSessions = class {
    */
   async records(id, options = {}) {
     const path = `/v1/sessions/${enc(id)}/records`;
-    const query = buildQuery({ cursor: options.cursor, limit: options.limit });
+    const query = buildQuery({ cursor: options.cursor, limit: options.limit, message_id: options.message_id });
     const response = await this.transport.request("GET", path, { query });
     return new Page(
       response,
@@ -1996,8 +1951,9 @@ var EllipsisSessions = class {
    * Send a message to a session.
    *
    * 409 for mention, non-interactive, closed, and out-of-budget
-   * sessions. Returns the created message and its turn; a retried send
-   * with the same idempotency_key returns the original ones.
+   * sessions. Returns the created message; a retried send with the
+   * same idempotency_key returns the original one. The message is
+   * answered once the session's status is `idle` or `closed`.
    *
    * Required permissions: write:sessions.
    * API key: Supported.
@@ -2058,11 +2014,11 @@ var EllipsisSessions = class {
   /**
    * Stop Session
    *
-   * Stop the turn in progress and return the session.
+   * Stop the session's work and return it.
    *
-   * The turn ends `stopped`; the conversation stays open. 409 when no
-   * turn is queued, preparing, or running. The stopping user is recorded only
-   * when the caller's credential maps to a GitHub account.
+   * The running message ends `stopped` and every queued message is
+   * cancelled, so the session goes `idle` (or `closed` when it was
+   * not interactive). 409 when the session is idle or closed already.
    *
    * Required permissions: write:sessions.
    * API key: Supported.
@@ -2600,5 +2556,5 @@ export {
   Transport,
   TransportError,
   UnprocessableError,
-  isTurnFinal
+  isSessionSettled
 };

package/dist/store/index.d.ts

@@ -1,14 +1,13 @@
-import { s as CodexAgentMessage, cM as SessionRecord, M as CodexFileChangeItem, K as CodexEvent, Z as CodexMcpToolCallItem, c9 as SdkRecord, cm as Session, cF as SessionMessage, d2 as StreamFrame } from '../types-BrLpRRde.js';
+import { s as CodexAgentMessage, cQ as SessionRecord, N as CodexFileChangeItem, L as CodexEvent, _ as CodexMcpToolCallItem, ce as SdkRecord, cr as Session, d1 as StreamFrame } from '../types-BXbnHOQe.js';
 
 type WorkPhase = 'queued' | 'preparing' | 'starting' | 'working';
-interface TurnTiming {
-    id: string;
+interface MessageTiming {
     startedAt: string | null;
     completedAt: string | null;
 }
 interface MessageProgress {
     phase: WorkPhase | null;
-    turns: TurnTiming[];
+    timing: MessageTiming;
 }
 
 interface ChatToolNode {
@@ -50,7 +49,6 @@ type ChatNode = {
 interface ChatTurn {
     key: string;
     messageId?: string;
-    turnId?: string;
     role: 'assistant' | 'user' | 'lifecycle';
     nodes: ChatNode[];
     startedAt: string | null;
@@ -70,10 +68,6 @@ declare function groupRecordsToChatTurns(records: readonly SessionRecord[], sess
         prompt?: string | null;
     } | null;
     created_at: string;
-    turn?: {
-        id: string;
-        index: number;
-    } | null;
 } | null): ChatTurn[];
 
 type RecordSlice = {
@@ -81,8 +75,7 @@ type RecordSlice = {
     source: string;
     record_type: string;
     payload: Record<string, unknown>;
-    turn_id?: string | null;
-    session_message_id?: string | null;
+    message_id?: string | null;
 };
 declare function recordSlice(records: readonly SessionRecord[]): readonly RecordSlice[];
 declare function humanDuration(seconds: number): string;
@@ -214,23 +207,24 @@ interface ToolActivity {
 declare function toolActivities(item: TranscriptItem): ToolActivity[];
 declare function activitySummary(activities: readonly ToolActivity[]): string;
 
-declare function environmentOutputStep(payload: Record<string, unknown>): string;
-declare function environmentOutputLines(payload: Record<string, unknown>): string[];
-declare function environmentOutputLine(payload: Record<string, unknown>): string | null;
+declare function environmentOutputStep(source: object): string;
+declare function environmentOutputLines(source: object): string[];
+declare function environmentOutputLine(source: object): string | null;
 declare function cacheTierLabel(tier: unknown): string | null;
 declare function environmentPhaseLabel(phase: unknown): string;
-declare function turnEndedText(payload: Record<string, unknown>): string | null;
-declare function lifecycleText(recordType: string, payload: Record<string, unknown>): string | null;
+declare function messageEndedText(source: object): string | null;
+declare function lifecycleText(recordType: string, source: object): string | null;
 
 declare function claudePayload(record: SessionRecord): SdkRecord | null;
 
+declare function codexSubagentThreads(records: readonly SessionRecord[]): Set<string>;
+declare function isCodexSubagentRecord(threads: ReadonlySet<string>, record: SessionRecord): boolean;
+
 declare function isConversationOver(session: Session): boolean;
 interface SessionTranscriptSnapshot {
     session: Session | null;
     records: readonly SessionRecord[];
-    messages: readonly SessionMessage[];
     acknowledgedMessageIds: ReadonlySet<string>;
-    historyTruncated: boolean;
     liveText: string;
     liveSummary: string;
     liveOutputTokens: number | null;
@@ -240,27 +234,22 @@ interface SessionTranscriptSnapshot {
 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;
     private listeners;
     private acknowledged;
-    private inbox;
     private cursorSeq;
     private turnsFor;
     private turnsSession;
     private turnsCache;
-    private summaryTurnId;
+    private summaryMessageId;
     get cursor(): number;
     subscribe: (listener: () => void) => (() => void);
     getSnapshot: () => SessionTranscriptSnapshot;
     chatTurns: () => ChatTurn[];
-    private pendingMessages;
-    private applyMessageRecord;
     ingest: (rawFrame: StreamFrame) => void;
 }
 
-export { BRANCH_GLYPH, type ChatNode, type ChatToolNode, type ChatTurn, type EntryBody, type EnvironmentLogKind, type EnvironmentLogLine, type EnvironmentState, type EventToItemsOptions, type ItemKind, LIVE_GLYPH, type LedgerEntry, type MessageProgress, type PlacedItem, type RecordSlice, type SessionTranscriptSnapshot, SessionTranscriptStore, StreamFrame, type ToolActivity, type TranscriptItem, type TurnTiming, USER_BAR, type WorkPhase, activitySummary, awaitingAgentPhase, cacheTierLabel, chatTurnsToItems, clampLines, claudePayload, codexChangedPaths, codexEventToItems, codexMcpToolName, collapseToolRuns, deliveredUnechoedSends, deriveEnvironmentState, emptySessionTranscriptSnapshot, entryBody, entrySeconds, environmentOutputLine, environmentOutputLines, environmentOutputStep, environmentPhaseLabel, environmentSummary, eventToItems, foldCosts, foldGutter, foldRun, formatDuration, groupRecordsToChatTurns, gutterFor, hookPhrase, humanDuration, isConnectVisibleRecord, isConversationOver, isFoldable, isToolActivity, isToolFold, isWorkFold, lastLines, layOutItems, lifecycleText, oneLine, pendingToolCalls, reasoningSummaryTitle, recordSlice, recordToItems, resultCostUsd, seedTranscriptStore, sessionLogText, splitLedger, startupHeadline, startupSettled, statusActivityText, summarizeToolInput, tailLines, toolActivities, toolResultText, toolRunMembers, turnEndedText };
+export { BRANCH_GLYPH, type ChatNode, type ChatToolNode, type ChatTurn, type EntryBody, type EnvironmentLogKind, type EnvironmentLogLine, type EnvironmentState, type EventToItemsOptions, type ItemKind, LIVE_GLYPH, type LedgerEntry, type MessageProgress, type MessageTiming, type PlacedItem, type RecordSlice, type SessionTranscriptSnapshot, SessionTranscriptStore, StreamFrame, type ToolActivity, type TranscriptItem, USER_BAR, type WorkPhase, activitySummary, awaitingAgentPhase, cacheTierLabel, chatTurnsToItems, clampLines, claudePayload, codexChangedPaths, codexEventToItems, codexMcpToolName, codexSubagentThreads, collapseToolRuns, deliveredUnechoedSends, deriveEnvironmentState, emptySessionTranscriptSnapshot, entryBody, entrySeconds, environmentOutputLine, environmentOutputLines, environmentOutputStep, environmentPhaseLabel, environmentSummary, eventToItems, foldCosts, foldGutter, foldRun, formatDuration, groupRecordsToChatTurns, gutterFor, hookPhrase, humanDuration, isCodexSubagentRecord, isConnectVisibleRecord, isConversationOver, isFoldable, isToolActivity, isToolFold, isWorkFold, lastLines, layOutItems, lifecycleText, messageEndedText, oneLine, pendingToolCalls, reasoningSummaryTitle, recordSlice, recordToItems, resultCostUsd, seedTranscriptStore, sessionLogText, splitLedger, startupHeadline, startupSettled, statusActivityText, summarizeToolInput, tailLines, toolActivities, toolResultText, toolRunMembers };