@ellipsis-dev/sdk 0.15.1 → 0.17.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-D9g-eZui.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-D9g-eZui.js';
+import { c as components } from './types--VF0yCc1.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--VF0yCc1.js';
 
 interface CursorResponse {
     has_more: boolean;
@@ -75,23 +75,15 @@ declare class EllipsisAgentsConfigs {
     /**
      * Create Agent Config
      *
-     * Create an agent config.
+     * Create an agent config, managed through the API: no file, live
+     * immediately. To put its definition in a repository instead, create
+     * it here and then POST /v1/agents/configs/{config_id}/link.
      *
-     * Name a repository and Ellipsis opens a pull request adding the
-     * config file to agents/ there; the agent goes live when it
-     * merges. Omit it and the agent is created here, with no file,
-     * live immediately — and every file reference in it must name the
-     * repository it lives in.
-     *
-     * Accepts an inline config or a gallery template slug. 409 when
-     * another live agent already holds the name.
+     * 409 when another live agent already holds the name.
      */
-    create(options?: {
-        config?: S['AgentConfig'] | null;
-        path?: string | null;
-        repository?: string | null;
-        template_id?: string | null;
-    }): Promise<S['CreateAgentConfigResponse']>;
+    create(options: {
+        config: S['AgentConfig'];
+    }): Promise<S['AgentConfigResponse']>;
     /**
      * Delete Agent Config
      *
@@ -350,6 +342,97 @@ declare class EllipsisAuth {
     readonly cli: EllipsisAuthCli;
     constructor(transport: Transport);
 }
+declare class EllipsisEnvironmentsDefaults {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Delete Environment Default
+     *
+     * Clear a default environment.
+     *
+     * Addressed by rung: the account rung (repository omitted) or a
+     * repository rung. Refused for sandbox tokens.
+     */
+    delete(options?: {
+        repository?: string | null;
+    }): Promise<void>;
+    /**
+     * List Environment Defaults
+     *
+     * Get the default environments.
+     *
+     * The account-wide default and the per-repository defaults, as
+     * environment ids. Repo rungs are keyed "owner/name".
+     */
+    list(): Promise<S['EnvironmentDefaults']>;
+    /**
+     * Put Environment Default
+     *
+     * Set a default environment.
+     *
+     * Addressed by rung: the account rung (repository omitted) or a
+     * repository rung ("owner/name"); the environment by id or name.
+     * Returns the full resulting ladder. Refused for sandbox tokens.
+     */
+    set(options: {
+        environment: string;
+        repository?: string | null;
+    }): Promise<S['EnvironmentDefaults']>;
+}
+declare class EllipsisEnvironments {
+    private readonly transport;
+    readonly defaults: EllipsisEnvironmentsDefaults;
+    constructor(transport: Transport);
+    /**
+     * Create Environment
+     *
+     * Create an environment, managed through the API: no file, live
+     * immediately. To define it in a repository instead, commit a
+     * `kind: environment` YAML under an agents directory.
+     *
+     * 409 when another live environment already holds the name.
+     */
+    create(options: {
+        environment: S['EnvironmentConfig'];
+    }): Promise<S['EnvironmentResponse']>;
+    /**
+     * Delete Environment
+     *
+     * Delete an environment, by id or by name.
+     *
+     * Always succeeds, even while agents still reference it — their next
+     * session start fails with a clear error naming the missing
+     * environment. Past sessions remain readable. Only for environments
+     * managed through this API — delete the file to remove one defined
+     * by a repository.
+     */
+    delete(environment_id: string): Promise<void>;
+    /**
+     * Get Environment
+     *
+     * Return one saved environment, by id or by name.
+     */
+    get(environment_id: string): Promise<S['EnvironmentResponse']>;
+    /**
+     * List Environments
+     *
+     * List saved environments.
+     */
+    list(): Promise<S['EnvironmentsListResponse']>;
+    /**
+     * Update Environment
+     *
+     * Replace an environment's definition, by id or by name.
+     *
+     * The whole definition is replaced, live at once — future sessions
+     * resolve the new body; running sessions keep the one frozen at
+     * their start. Only for environments managed through this API: one
+     * defined by a repository file is a 409.
+     */
+    update(environment_id: string, options: {
+        environment: S['EnvironmentConfig'];
+    }): Promise<S['EnvironmentResponse']>;
+}
 declare class EllipsisFiles {
     private readonly transport;
     constructor(transport: Transport);
@@ -790,8 +873,7 @@ declare class EllipsisSessions {
      */
     replay(session_id: string, options?: {
         config_id?: string | null;
-        config_override?: Record<string, unknown> | null;
-        config_override_yaml?: string | null;
+        override?: Record<string, unknown> | null;
         prompt?: string | null;
     }): Promise<S['SessionResponse']>;
     /**
@@ -839,25 +921,25 @@ declare class EllipsisSessions {
      *
      * Start a cloud agent session.
      *
-     * Provide at most one of config_id (an id or an agent name),
-     * config, or
-     * template_id; with none, the account's default-config ladder
-     * resolves the config. 400 when idle_start is combined with
-     * prompt or input. 422 when the agent declares an
-     * input schema and the request's input is absent or invalid.
+     * Provide at most one of config_id (an id or an agent name) or
+     * config; with neither, the account's default-config ladder
+     * resolves the config. `prompt` is the first message; omit it and
+     * the session starts idle, waiting for one. 400 when
+     * interactive=false and there is no prompt or input. 422 when the
+     * agent declares an input schema and the request's input is absent
+     * or invalid.
      */
     start(options?: {
         config?: S['AgentConfig'] | null;
         config_id?: string | null;
-        config_override?: Record<string, unknown> | null;
-        config_override_yaml?: string | null;
+        environment?: string | null;
         force_rebuild?: boolean;
-        idle_start?: boolean;
         input?: Record<string, unknown> | null;
+        interactive?: boolean;
         metadata?: Record<string, string>;
+        override?: Record<string, unknown> | null;
         prompt?: string | null;
         repository?: string | null;
-        template_id?: string | null;
     }): Promise<S['SessionResponse']>;
     /**
      * Stop Agent Session
@@ -879,6 +961,7 @@ declare class Ellipsis {
     readonly alerts: EllipsisAlerts;
     readonly analytics: EllipsisAnalytics;
     readonly auth: EllipsisAuth;
+    readonly environments: EllipsisEnvironments;
     readonly files: EllipsisFiles;
     readonly integrations: EllipsisIntegrations;
     readonly memories: EllipsisMemories;

package/dist/index.js

@@ -249,20 +249,15 @@ var EllipsisAgentsConfigs = class {
   /**
    * Create Agent Config
    *
-   * Create an agent config.
+   * Create an agent config, managed through the API: no file, live
+   * immediately. To put its definition in a repository instead, create
+   * it here and then POST /v1/agents/configs/{config_id}/link.
    *
-   * Name a repository and Ellipsis opens a pull request adding the
-   * config file to agents/ there; the agent goes live when it
-   * merges. Omit it and the agent is created here, with no file,
-   * live immediately — and every file reference in it must name the
-   * repository it lives in.
-   *
-   * Accepts an inline config or a gallery template slug. 409 when
-   * another live agent already holds the name.
+   * 409 when another live agent already holds the name.
    */
-  async create(options = {}) {
+  async create(options) {
     const path = "/v1/agents/configs";
-    const body = buildBody({ config: options.config, path: options.path, repository: options.repository, template_id: options.template_id });
+    const body = buildBody({ config: options.config });
     return await this.transport.request("POST", path, { body });
   }
   /**
@@ -571,6 +566,121 @@ var EllipsisAuth = class {
   transport;
   cli;
 };
+var EllipsisEnvironmentsDefaults = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Delete Environment Default
+   *
+   * Clear a default environment.
+   *
+   * Addressed by rung: the account rung (repository omitted) or a
+   * repository rung. Refused for sandbox tokens.
+   */
+  async delete(options = {}) {
+    const path = "/v1/environments/defaults";
+    const query = buildQuery({ repository: options.repository });
+    await this.transport.request("DELETE", path, { query });
+  }
+  /**
+   * List Environment Defaults
+   *
+   * Get the default environments.
+   *
+   * The account-wide default and the per-repository defaults, as
+   * environment ids. Repo rungs are keyed "owner/name".
+   */
+  async list() {
+    const path = "/v1/environments/defaults";
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * Put Environment Default
+   *
+   * Set a default environment.
+   *
+   * Addressed by rung: the account rung (repository omitted) or a
+   * repository rung ("owner/name"); the environment by id or name.
+   * Returns the full resulting ladder. Refused for sandbox tokens.
+   */
+  async set(options) {
+    const path = "/v1/environments/defaults";
+    const body = buildBody({ environment: options.environment, repository: options.repository });
+    return await this.transport.request("PUT", path, { body });
+  }
+};
+var EllipsisEnvironments = class {
+  constructor(transport) {
+    this.transport = transport;
+    this.defaults = new EllipsisEnvironmentsDefaults(transport);
+  }
+  transport;
+  defaults;
+  /**
+   * Create Environment
+   *
+   * Create an environment, managed through the API: no file, live
+   * immediately. To define it in a repository instead, commit a
+   * `kind: environment` YAML under an agents directory.
+   *
+   * 409 when another live environment already holds the name.
+   */
+  async create(options) {
+    const path = "/v1/environments";
+    const body = buildBody({ environment: options.environment });
+    return await this.transport.request("POST", path, { body });
+  }
+  /**
+   * Delete Environment
+   *
+   * Delete an environment, by id or by name.
+   *
+   * Always succeeds, even while agents still reference it — their next
+   * session start fails with a clear error naming the missing
+   * environment. Past sessions remain readable. Only for environments
+   * managed through this API — delete the file to remove one defined
+   * by a repository.
+   */
+  async delete(environment_id) {
+    const path = `/v1/environments/${enc(environment_id)}`;
+    await this.transport.request("DELETE", path);
+  }
+  /**
+   * Get Environment
+   *
+   * Return one saved environment, by id or by name.
+   */
+  async get(environment_id) {
+    const path = `/v1/environments/${enc(environment_id)}`;
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * List Environments
+   *
+   * List saved environments.
+   */
+  async list() {
+    const path = "/v1/environments";
+    return await this.transport.request("GET", path);
+  }
+  /**
+   * Update Environment
+   *
+   * Replace an environment's definition, by id or by name.
+   *
+   * The whole definition is replaced, live at once — future sessions
+   * resolve the new body; running sessions keep the one frozen at
+   * their start. Only for environments managed through this API: one
+   * defined by a repository file is a 409.
+   */
+  async update(environment_id, options) {
+    const path = `/v1/environments/${enc(environment_id)}`;
+    const body = buildBody({ environment: options.environment });
+    return await this.transport.request("PUT", path, { body });
+  }
+};
 var EllipsisFiles = class {
   constructor(transport) {
     this.transport = transport;
@@ -1107,7 +1217,7 @@ var EllipsisSessions = class {
    */
   async replay(session_id, options = {}) {
     const path = `/v1/sessions/${enc(session_id)}/replay`;
-    const body = buildBody({ config_id: options.config_id, config_override: options.config_override, config_override_yaml: options.config_override_yaml, prompt: options.prompt });
+    const body = buildBody({ config_id: options.config_id, override: options.override, prompt: options.prompt });
     return await this.transport.request("POST", path, { body });
   }
   /**
@@ -1148,16 +1258,17 @@ var EllipsisSessions = class {
    *
    * Start a cloud agent session.
    *
-   * Provide at most one of config_id (an id or an agent name),
-   * config, or
-   * template_id; with none, the account's default-config ladder
-   * resolves the config. 400 when idle_start is combined with
-   * prompt or input. 422 when the agent declares an
-   * input schema and the request's input is absent or invalid.
+   * Provide at most one of config_id (an id or an agent name) or
+   * config; with neither, the account's default-config ladder
+   * resolves the config. `prompt` is the first message; omit it and
+   * the session starts idle, waiting for one. 400 when
+   * interactive=false and there is no prompt or input. 422 when the
+   * agent declares an input schema and the request's input is absent
+   * or invalid.
    */
   async start(options = {}) {
     const path = "/v1/sessions";
-    const body = buildBody({ config: options.config, config_id: options.config_id, config_override: options.config_override, config_override_yaml: options.config_override_yaml, force_rebuild: options.force_rebuild, idle_start: options.idle_start, input: options.input, metadata: options.metadata, prompt: options.prompt, repository: options.repository, template_id: options.template_id });
+    const body = buildBody({ config: options.config, config_id: options.config_id, environment: options.environment, force_rebuild: options.force_rebuild, input: options.input, interactive: options.interactive, metadata: options.metadata, override: options.override, prompt: options.prompt, repository: options.repository });
     return await this.transport.request("POST", path, { body });
   }
   /**
@@ -1190,6 +1301,7 @@ var Ellipsis = class {
   alerts;
   analytics;
   auth;
+  environments;
   files;
   integrations;
   memories;
@@ -1203,6 +1315,7 @@ var Ellipsis = class {
     this.alerts = new EllipsisAlerts(this.transport);
     this.analytics = new EllipsisAnalytics(this.transport);
     this.auth = new EllipsisAuth(this.transport);
+    this.environments = new EllipsisEnvironments(this.transport);
     this.files = new EllipsisFiles(this.transport);
     this.integrations = new EllipsisIntegrations(this.transport);
     this.memories = new EllipsisMemories(this.transport);

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-D9g-eZui.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--VF0yCc1.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 };