agentbox-sdk 0.1.0 → 0.1.3

package/dist/chunk-ZOWBRUQR.js

@@ -0,0 +1,476 @@
+import {
+  AgentProvider
+} from "./chunk-GOFJNFAD.js";
+
+// src/events/normalized.ts
+function createNormalizedEvent(type, base, extra) {
+  return {
+    type,
+    provider: base.provider,
+    runId: base.runId,
+    timestamp: base.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    raw: base.raw,
+    meta: base.meta,
+    ...extra ?? {}
+  };
+}
+function normalizeRawAgentEvent(event) {
+  const payload = event.payload;
+  const common = {
+    provider: event.provider,
+    runId: event.runId,
+    raw: event,
+    timestamp: event.timestamp
+  };
+  if (event.type === "assistant" && Array.isArray(
+    payload?.message?.content
+  )) {
+    const blocks = (payload?.message).content;
+    const text = blocks.filter((block) => block.type === "text").map((block) => String(block.text ?? "")).join("");
+    return [
+      createNormalizedEvent("message.started", common),
+      ...text ? [createNormalizedEvent("text.delta", common, { delta: text })] : [],
+      createNormalizedEvent("message.completed", common, { text }),
+      createNormalizedEvent("run.completed", common, { text })
+    ];
+  }
+  if (event.type.includes("delta")) {
+    const delta = String(
+      payload?.delta ?? payload?.text ?? payload?.["content"] ?? ""
+    );
+    const normalizedType = event.type.includes("reasoning") ? "reasoning.delta" : "text.delta";
+    return [createNormalizedEvent(normalizedType, common, { delta })];
+  }
+  if (event.type.includes("tool")) {
+    const toolName = String(payload?.toolName ?? payload?.tool_name ?? "tool");
+    if (event.type.includes("completed") || event.type.includes("summary")) {
+      return [
+        createNormalizedEvent("tool.call.completed", common, {
+          toolName,
+          callId: payload?.callId ?? payload?.tool_use_id,
+          output: payload?.output ?? payload?.result
+        })
+      ];
+    }
+    return [
+      createNormalizedEvent("tool.call.started", common, {
+        toolName,
+        callId: payload?.callId ?? payload?.tool_use_id,
+        input: payload?.input
+      })
+    ];
+  }
+  if (event.type === "result") {
+    const text = String(payload?.result ?? payload?.text ?? "");
+    return [createNormalizedEvent("run.completed", common, { text })];
+  }
+  if (event.type === "error") {
+    return [
+      createNormalizedEvent("run.error", common, {
+        error: String(
+          payload?.message ?? payload?.error ?? "Unknown agent error"
+        )
+      })
+    ];
+  }
+  return [];
+}
+
+// src/events/ai-sdk.ts
+function toAISDKEvent(event) {
+  switch (event.type) {
+    case "run.started":
+      return {
+        type: "response-start",
+        id: event.runId,
+        provider: event.provider
+      };
+    case "message.injected":
+      return {
+        type: "message-injected",
+        id: event.runId,
+        provider: event.provider,
+        content: event.content
+      };
+    case "text.delta":
+      return {
+        type: "text-delta",
+        id: event.runId,
+        provider: event.provider,
+        textDelta: event.delta
+      };
+    case "reasoning.delta":
+      return {
+        type: "reasoning-delta",
+        id: event.runId,
+        provider: event.provider,
+        textDelta: event.delta
+      };
+    case "tool.call.started":
+      return {
+        type: "tool-input-start",
+        id: event.runId,
+        provider: event.provider,
+        toolName: event.toolName,
+        callId: event.callId
+      };
+    case "tool.call.delta":
+      return {
+        type: "tool-input-delta",
+        id: event.runId,
+        provider: event.provider,
+        toolName: event.toolName,
+        callId: event.callId,
+        inputTextDelta: event.delta
+      };
+    case "tool.call.completed":
+      return {
+        type: "tool-output-available",
+        id: event.runId,
+        provider: event.provider,
+        toolName: event.toolName,
+        callId: event.callId,
+        output: event.output
+      };
+    case "permission.requested":
+      return {
+        type: "permission-requested",
+        id: event.runId,
+        provider: event.provider,
+        requestId: event.requestId,
+        kind: event.kind,
+        title: event.title,
+        message: event.message,
+        input: event.input,
+        canRemember: event.canRemember
+      };
+    case "permission.resolved":
+      return {
+        type: "permission-resolved",
+        id: event.runId,
+        provider: event.provider,
+        requestId: event.requestId,
+        decision: event.decision,
+        remember: event.remember
+      };
+    case "message.completed":
+    case "run.completed":
+      return {
+        type: "response-finish",
+        id: event.runId,
+        provider: event.provider,
+        text: event.text
+      };
+    case "run.error":
+      return {
+        type: "response-error",
+        id: event.runId,
+        provider: event.provider,
+        error: event.error
+      };
+    default:
+      return null;
+  }
+}
+async function* toAISDKStream(events) {
+  for await (const event of events) {
+    const mapped = toAISDKEvent(event);
+    if (mapped) {
+      yield mapped;
+    }
+  }
+}
+
+// src/events/log-assembler.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+var CodexLogAssembler = class {
+  byItemId = /* @__PURE__ */ new Map();
+  textByItemId = /* @__PURE__ */ new Map();
+  process(event) {
+    if (!isRecord(event)) {
+      return [];
+    }
+    const method = typeof event.method === "string" ? event.method : void 0;
+    const params = isRecord(event.params) ? event.params : {};
+    const item = isRecord(params.item) ? clone(params.item) : null;
+    if (method === "item/started" || method === "item/updated" || method === "item/completed") {
+      if (item && typeof item.id === "string") {
+        this.byItemId.set(item.id, clone(event));
+        const text = typeof item.text === "string" ? item.text : void 0;
+        if (text !== void 0) {
+          this.textByItemId.set(item.id, text);
+        }
+        const aggregated = typeof item.aggregated_output === "string" ? item.aggregated_output : void 0;
+        if (aggregated !== void 0) {
+          this.textByItemId.set(item.id, aggregated);
+        }
+      }
+      return [clone(event)];
+    }
+    if (method === "item/agentMessage/delta") {
+      const itemId = typeof params.itemId === "string" ? params.itemId : null;
+      const delta = typeof params.delta === "string" ? params.delta : "";
+      if (!itemId || !delta) return [];
+      const text = (this.textByItemId.get(itemId) ?? "") + delta;
+      this.textByItemId.set(itemId, text);
+      return [this.upsertItem(itemId, "agentMessage", { text })];
+    }
+    if (method === "item/reasoning/summaryTextDelta" || method === "item/reasoning/textDelta") {
+      const itemId = typeof params.itemId === "string" ? params.itemId : null;
+      const delta = typeof params.delta === "string" ? params.delta : typeof params.text === "string" ? params.text : "";
+      if (!itemId || !delta) return [];
+      const text = (this.textByItemId.get(itemId) ?? "") + delta;
+      this.textByItemId.set(itemId, text);
+      return [
+        this.upsertItem(itemId, "reasoning", {
+          summary: text,
+          text
+        })
+      ];
+    }
+    if (method === "item/commandExecution/outputDelta") {
+      const itemId = typeof params.itemId === "string" ? params.itemId : null;
+      const chunk = typeof params.chunk === "string" ? params.chunk : typeof params.delta === "string" ? params.delta : typeof params.text === "string" ? params.text : "";
+      if (!itemId || !chunk) return [];
+      const text = (this.textByItemId.get(itemId) ?? "") + chunk;
+      this.textByItemId.set(itemId, text);
+      return [
+        this.upsertItem(itemId, "commandExecution", {
+          aggregatedOutput: text,
+          status: "inProgress"
+        })
+      ];
+    }
+    return [clone(event)];
+  }
+  /**
+   * Repopulate state from a sequence of previously-assembled snapshots so the
+   * assembler can resume mid-run (used by reconnecting UI clients).
+   */
+  seed(snapshots) {
+    this.byItemId.clear();
+    this.textByItemId.clear();
+    for (const snapshot of snapshots) {
+      if (!isRecord(snapshot)) continue;
+      const params = isRecord(snapshot.params) ? snapshot.params : {};
+      const item = isRecord(params.item) ? params.item : null;
+      if (!item || typeof item.id !== "string") continue;
+      this.byItemId.set(item.id, clone(snapshot));
+      const text = typeof item.text === "string" ? item.text : void 0;
+      if (text !== void 0) {
+        this.textByItemId.set(item.id, text);
+      }
+      const aggregated = typeof item.aggregated_output === "string" ? item.aggregated_output : void 0;
+      if (aggregated !== void 0) {
+        this.textByItemId.set(item.id, aggregated);
+      }
+    }
+  }
+  upsertItem(itemId, itemType, patch) {
+    const existing = this.byItemId.get(itemId);
+    const existingParams = isRecord(existing?.params) ? existing.params : {};
+    const existingItem = isRecord(existingParams.item) ? existingParams.item : {};
+    const next = {
+      method: "item/updated",
+      params: {
+        ...existingParams,
+        item: {
+          ...existingItem,
+          id: itemId,
+          type: itemType,
+          ...patch
+        }
+      }
+    };
+    this.byItemId.set(itemId, next);
+    return clone(next);
+  }
+};
+var OpenCodeLogAssembler = class {
+  userMessageIds = /* @__PURE__ */ new Set();
+  textByPartId = /* @__PURE__ */ new Map();
+  byPartId = /* @__PURE__ */ new Map();
+  process(event) {
+    if (!isRecord(event)) {
+      return [];
+    }
+    const type = typeof event.type === "string" ? event.type : "";
+    const properties = isRecord(event.properties) ? event.properties : {};
+    const info = isRecord(properties.info) ? properties.info : null;
+    if (type === "message.updated" && typeof info?.id === "string" && info.role === "user") {
+      this.userMessageIds.add(info.id);
+      return [clone(event)];
+    }
+    if (type === "message.part.delta") {
+      const partId = typeof properties.partID === "string" ? properties.partID : null;
+      const messageId = typeof properties.messageID === "string" ? properties.messageID : null;
+      const delta = typeof properties.delta === "string" ? properties.delta : "";
+      if (!partId || !delta || properties.field !== "text" || messageId && this.userMessageIds.has(messageId)) {
+        return [];
+      }
+      const text = (this.textByPartId.get(partId) ?? "") + delta;
+      this.textByPartId.set(partId, text);
+      return [
+        this.upsertPart(partId, {
+          id: partId,
+          messageID: messageId ?? void 0,
+          type: "text",
+          text
+        })
+      ];
+    }
+    const part = isRecord(properties.part) ? properties.part : isRecord(event.part) ? event.part : null;
+    if (part && typeof part.id === "string") {
+      if (part.messageID && this.userMessageIds.has(String(part.messageID))) {
+        return [];
+      }
+      const previous = this.byPartId.get(part.id);
+      if (part.type === "text" && previous && isRecord(previous.properties?.part)) {
+        const previousPart = previous.properties.part;
+        const previousText = typeof previousPart.text === "string" ? previousPart.text : "";
+        const nextText = typeof part.text === "string" ? part.text : "";
+        if (nextText.length < previousText.length) {
+          return [clone(previous)];
+        }
+      }
+      this.byPartId.set(part.id, clone(event));
+    }
+    return [clone(event)];
+  }
+  seed(snapshots) {
+    this.userMessageIds.clear();
+    this.textByPartId.clear();
+    this.byPartId.clear();
+    for (const snapshot of snapshots) {
+      if (!isRecord(snapshot)) continue;
+      const type = typeof snapshot.type === "string" ? snapshot.type : "";
+      const properties = isRecord(snapshot.properties) ? snapshot.properties : {};
+      const info = isRecord(properties.info) ? properties.info : null;
+      if (type === "message.updated" && typeof info?.id === "string" && info.role === "user") {
+        this.userMessageIds.add(info.id);
+        continue;
+      }
+      const part = isRecord(properties.part) ? properties.part : isRecord(snapshot.part) ? snapshot.part : null;
+      if (part && typeof part.id === "string") {
+        this.byPartId.set(part.id, clone(snapshot));
+        if (typeof part.text === "string") {
+          this.textByPartId.set(part.id, part.text);
+        }
+      }
+    }
+  }
+  upsertPart(partId, part) {
+    const next = {
+      type: "message.part.updated",
+      properties: {
+        partID: partId,
+        part
+      }
+    };
+    this.byPartId.set(partId, next);
+    return clone(next);
+  }
+};
+var ProviderLogAssembler = class {
+  codex = new CodexLogAssembler();
+  openCode = new OpenCodeLogAssembler();
+  /**
+   * Process a raw provider event and return any newly-produced assembled
+   * snapshots. May return an empty array when the event is non-stateful (e.g.
+   * a delta with no payload) or already represented by a previous snapshot.
+   */
+  process(provider, event) {
+    if (provider === AgentProvider.Codex || provider === "codex") {
+      return this.codex.process(event);
+    }
+    if (provider === AgentProvider.OpenCode || provider === "opencode") {
+      return this.openCode.process(event);
+    }
+    if (isRecord(event)) {
+      return [clone(event)];
+    }
+    return [];
+  }
+  /**
+   * Re-seed the assembler from a sequence of previously-assembled snapshots
+   * so that subsequent `process()` calls produce snapshots consistent with
+   * the server-side state. Used by reconnecting UI clients after they replay
+   * the persisted history.
+   */
+  seedFromSnapshots(provider, snapshots) {
+    if (provider === AgentProvider.Codex || provider === "codex") {
+      this.codex.seed(snapshots);
+      return;
+    }
+    if (provider === AgentProvider.OpenCode || provider === "opencode") {
+      this.openCode.seed(snapshots);
+      return;
+    }
+  }
+  /**
+   * Given a sequence of assembled snapshots (typically the persisted history
+   * for a run), return one entry per item / part with the latest snapshot
+   * winning, preserving first-seen order.
+   *
+   * For providers that don't have a stateful item model (Claude Code), or
+   * for unrecognized snapshot shapes, entries are returned in original order
+   * with no dedup.
+   */
+  static dedupeSnapshots(provider, snapshots) {
+    if (provider === AgentProvider.Codex || provider === "codex") {
+      return dedupeByKey(snapshots, (snapshot) => {
+        const params = isRecord(snapshot.params) ? snapshot.params : null;
+        const item = params && isRecord(params.item) ? params.item : null;
+        return item && typeof item.id === "string" ? `item:${item.id}` : null;
+      });
+    }
+    if (provider === AgentProvider.OpenCode || provider === "opencode") {
+      return dedupeByKey(snapshots, (snapshot) => {
+        const properties = isRecord(snapshot.properties) ? snapshot.properties : null;
+        const part = properties && isRecord(properties.part) ? properties.part : isRecord(snapshot.part) ? snapshot.part : null;
+        if (part && typeof part.id === "string") {
+          return `part:${part.id}`;
+        }
+        const info = properties && isRecord(properties.info) ? properties.info : null;
+        if (info && typeof info.id === "string") {
+          return `message:${info.id}`;
+        }
+        return null;
+      });
+    }
+    return snapshots.map(clone);
+  }
+};
+function dedupeByKey(snapshots, keyOf) {
+  const order = [];
+  const latestByKey = /* @__PURE__ */ new Map();
+  const passthrough = [];
+  snapshots.forEach((snapshot, index) => {
+    if (!isRecord(snapshot)) return;
+    const key = keyOf(snapshot);
+    if (!key) {
+      passthrough.push(clone(snapshot));
+      order.push(`pt:${index}`);
+      latestByKey.set(`pt:${index}`, clone(snapshot));
+      return;
+    }
+    if (!latestByKey.has(key)) {
+      order.push(key);
+    }
+    latestByKey.set(key, clone(snapshot));
+  });
+  return order.map((key) => latestByKey.get(key)).filter(Boolean);
+}
+
+export {
+  createNormalizedEvent,
+  normalizeRawAgentEvent,
+  toAISDKEvent,
+  toAISDKStream,
+  ProviderLogAssembler
+};

package/dist/cli.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 import {
   toShellCommand
-} from "./chunk-JFDP556Q.js";
+} from "./chunk-NSJM57Z4.js";
+import {
+  SandboxProvider
+} from "./chunk-GOFJNFAD.js";
 
 // src/sandbox-images/build.ts
 import { existsSync } from "fs";
@@ -77,14 +80,18 @@ async function buildSandboxImage(options) {
     options.cwd
   );
   switch (options.provider) {
-    case "local-docker":
+    case SandboxProvider.LocalDocker:
       return buildLocalDockerImage(definition, options);
-    case "modal":
+    case SandboxProvider.Modal:
       return buildModalImage(definition, options);
-    case "daytona":
+    case SandboxProvider.Daytona:
       return buildDaytonaSnapshot(definition, options);
-    case "e2b":
+    case SandboxProvider.E2B:
       return buildE2bTemplate(definition, options);
+    default:
+      throw new Error(
+        `Image building is not supported for provider "${options.provider}". Vercel sandboxes use runtime snapshots instead \u2014 see Sandbox.snapshot().`
+      );
   }
 }
 async function loadSandboxImageDefinition(preset, file, cwd = process.cwd()) {
@@ -371,7 +378,7 @@ function parseOptions(args) {
   return options;
 }
 function isSandboxProviderName(value) {
-  return value === "local-docker" || value === "modal" || value === "daytona" || value === "e2b";
+  return Object.values(SandboxProvider).includes(value);
 }
 function isBuiltInImageName(value) {
   return value === "browser-agent" || value === "computer-use";
@@ -380,8 +387,8 @@ function printHelp() {
   process.stdout.write(`agentbox
 
 Usage:
-  agentbox image build --provider <local-docker|modal|daytona|e2b> --preset <browser-agent|computer-use>
-  agentbox image build --provider <local-docker|modal|daytona|e2b> --file <path>
+  agentbox image build --provider <local-docker|modal|daytona|vercel|e2b> --preset <browser-agent|computer-use>
+  agentbox image build --provider <local-docker|modal|daytona|vercel|e2b> --file <path>
 
 Options:
   --image-name <name>        Override the built artifact name
@@ -390,6 +397,7 @@ Options:
 Environment:
   Modal: MODAL_TOKEN_ID, MODAL_TOKEN_SECRET, MODAL_ENVIRONMENT?, MODAL_ENDPOINT?
   Daytona: DAYTONA_API_KEY or DAYTONA_JWT_TOKEN, DAYTONA_ORGANIZATION_ID?, DAYTONA_API_URL?, DAYTONA_TARGET?
+  Vercel: VERCEL_TOKEN, VERCEL_TEAM_ID, VERCEL_PROJECT_ID
   E2B: E2B_API_KEY, E2B_DOMAIN?, E2B_ACCESS_TOKEN?
 `);
 }

package/dist/enums.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pure value-level provider enums.
+ *
+ * This file MUST NOT import anything from the rest of the SDK. It is used as
+ * a standalone tsup entry (`agentbox-sdk/enums`) so that client-side bundles
+ * in Next.js/browser contexts can reference `AgentProvider`/`SandboxProvider`
+ * without pulling in server-only modules like `net`, `crypto`, or the sandbox
+ * provider adapters.
+ */
+declare const AgentProvider: {
+    readonly ClaudeCode: "claude-code";
+    readonly OpenCode: "open-code";
+    readonly Codex: "codex";
+};
+type AgentProvider = (typeof AgentProvider)[keyof typeof AgentProvider];
+declare const SandboxProvider: {
+    readonly LocalDocker: "local-docker";
+    readonly Modal: "modal";
+    readonly Daytona: "daytona";
+    readonly Vercel: "vercel";
+    readonly E2B: "e2b";
+};
+type SandboxProvider = (typeof SandboxProvider)[keyof typeof SandboxProvider];
+
+export { AgentProvider, SandboxProvider };

package/dist/enums.js

@@ -0,0 +1,8 @@
+import {
+  AgentProvider,
+  SandboxProvider
+} from "./chunk-GOFJNFAD.js";
+export {
+  AgentProvider,
+  SandboxProvider
+};

package/dist/events/index.d.ts

@@ -1,6 +1,90 @@
-export { A as AISDKEvent, M as MessageCompletedEvent, N as MessageInjectedEvent, O as MessageStartedEvent, P as NormalizedAgentEvent, Q as NormalizedAgentEventBase, R as NormalizedAgentEventType, X as PermissionRequestedEvent, Y as PermissionResolvedEvent, Z as RawAgentEvent, _ as ReasoningDeltaEvent, a0 as RunCompletedEvent, a1 as RunErrorEvent, a2 as RunStartedEvent, a3 as TextDeltaEvent, a5 as ToolCallCompletedEvent, a6 as ToolCallDeltaEvent, a7 as ToolCallStartedEvent, aa as createNormalizedEvent, ab as normalizeRawAgentEvent, ac as toAISDKEvent, ad as toAISDKStream } from '../types-BwcoN0n-.js';
-import '../Sandbox-DTprxRZf.js';
+export { A as AISDKEvent, S as MessageCompletedEvent, T as MessageInjectedEvent, U as MessageStartedEvent, V as NormalizedAgentEvent, W as NormalizedAgentEventBase, X as NormalizedAgentEventType, a1 as PermissionRequestedEvent, a2 as PermissionResolvedEvent, a3 as RawAgentEvent, a4 as ReasoningDeltaEvent, a6 as RunCompletedEvent, a7 as RunErrorEvent, a8 as RunStartedEvent, a9 as TextDeltaEvent, ab as ToolCallCompletedEvent, ac as ToolCallDeltaEvent, ad as ToolCallStartedEvent, ag as createNormalizedEvent, ah as normalizeRawAgentEvent, ai as toAISDKEvent, aj as toAISDKStream } from '../types-B3N-Qo2q.js';
+import { AgentProvider } from '../enums.js';
+import '../Sandbox-CByFJI8X.js';
 import 'e2b';
+import '@vercel/sandbox';
 import '@daytonaio/sdk';
 import 'modal';
 import 'dockerode';
+
+/**
+ * Provider-aware log assembler for agentbox runs.
+ *
+ * Agentbox streams a sequence of raw provider events (deltas of text /
+ * reasoning / tool calls) for each `AgentRun` via `run.rawEvents()`. Most UIs
+ * ultimately want a stable "snapshot per item" view (one box per assistant
+ * message, one box per shell command, etc.) instead of the raw delta stream.
+ *
+ * This module converts deltas into snapshots while remaining transport- and
+ * persistence-agnostic so it can run in any environment that consumes the
+ * SDK's raw event stream:
+ *
+ *   - Server processes (e.g. orchestrators, log persisters) can call
+ *     `process()` to derive snapshots they push into a history store, then
+ *     persist a deduped view at end of run via the static `dedupeSnapshots`.
+ *   - Browser/UI clients can `seedFromSnapshots()` from a replayed history
+ *     and re-run `process()` over live deltas to keep state aligned with the
+ *     server without duplicating normalization logic.
+ *
+ * Constraints:
+ *   - No Node-only imports; this module must run in the browser. The
+ *     `agentbox-sdk/events` entrypoint is therefore safe for client bundles.
+ *   - Pure logic; transports (Redis, SSE, websockets, files, …) are entirely
+ *     the responsibility of the caller.
+ */
+
+type JsonRecord = Record<string, unknown>;
+/**
+ * Provider-aware assembler that routes raw events through the right
+ * per-provider implementation. Stateful: holds dedup/text maps so it can
+ * incrementally combine deltas into snapshots.
+ *
+ * @example Server-side use during an `AgentRun`:
+ * ```ts
+ * const assembler = new ProviderLogAssembler();
+ * for await (const raw of run.rawEvents()) {
+ *   const snapshots = assembler.process(raw.provider, raw.payload);
+ *   for (const snapshot of snapshots) historyStore.append(snapshot);
+ * }
+ * ```
+ *
+ * @example Reconnecting UI client:
+ * ```ts
+ * const assembler = new ProviderLogAssembler();
+ * const history = await fetchHistorySnapshots();
+ * assembler.seedFromSnapshots(provider, history);
+ * subscribeRawDeltas((event) => {
+ *   const snapshots = assembler.process(provider, event);
+ *   render(snapshots);
+ * });
+ * ```
+ */
+declare class ProviderLogAssembler {
+    private readonly codex;
+    private readonly openCode;
+    /**
+     * Process a raw provider event and return any newly-produced assembled
+     * snapshots. May return an empty array when the event is non-stateful (e.g.
+     * a delta with no payload) or already represented by a previous snapshot.
+     */
+    process(provider: AgentProvider | string | null | undefined, event: unknown): JsonRecord[];
+    /**
+     * Re-seed the assembler from a sequence of previously-assembled snapshots
+     * so that subsequent `process()` calls produce snapshots consistent with
+     * the server-side state. Used by reconnecting UI clients after they replay
+     * the persisted history.
+     */
+    seedFromSnapshots(provider: AgentProvider | string | null | undefined, snapshots: JsonRecord[]): void;
+    /**
+     * Given a sequence of assembled snapshots (typically the persisted history
+     * for a run), return one entry per item / part with the latest snapshot
+     * winning, preserving first-seen order.
+     *
+     * For providers that don't have a stateful item model (Claude Code), or
+     * for unrecognized snapshot shapes, entries are returned in original order
+     * with no dedup.
+     */
+    static dedupeSnapshots(provider: AgentProvider | string | null | undefined, snapshots: JsonRecord[]): JsonRecord[];
+}
+
+export { ProviderLogAssembler };

package/dist/events/index.js

@@ -1,10 +1,13 @@
 import {
+  ProviderLogAssembler,
   createNormalizedEvent,
   normalizeRawAgentEvent,
   toAISDKEvent,
   toAISDKStream
-} from "../chunk-7FLLQJ6J.js";
+} from "../chunk-ZOWBRUQR.js";
+import "../chunk-GOFJNFAD.js";
 export {
+  ProviderLogAssembler,
   createNormalizedEvent,
   normalizeRawAgentEvent,
   toAISDKEvent,