@ably/ai-transport 0.1.0 → 0.2.0

package/src/vercel/transport/index.ts

@@ -5,63 +5,64 @@
  * explicitly when using the Vercel AI SDK integration.
  *
  * ```ts
- * import { createClientTransport } from '@ably/ai-transport/vercel';
+ * import { createClientSession } from '@ably/ai-transport/vercel';
  *
- * const transport = createClientTransport({ channel });
+ * const session = createClientSession({ client, channelName: 'ai:demo' });
+ * await session.connect();
  * ```
  */
 
 // Chat transport adapter
 export type { ChatTransport, ChatTransportOptions, SendMessagesRequestContext } from './chat-transport.js';
-export { createChatTransport } from './chat-transport.js';
+export { createChatTransport, DEFAULT_VERCEL_API } from './chat-transport.js';
 
 import type * as AI from 'ai';
 
-import { createClientTransport as createCoreClientTransport } from '../../core/transport/client-transport.js';
-import { createServerTransport as createCoreServerTransport } from '../../core/transport/server-transport.js';
+import { createAgentSession as createCoreAgentSession } from '../../core/transport/agent-session.js';
+import { createClientSession as createCoreClientSession } from '../../core/transport/client-session.js';
 import type {
-  ClientTransport,
-  ClientTransportOptions,
-  ServerTransport,
-  ServerTransportOptions,
+  AgentSession,
+  AgentSessionOptions,
+  ClientSession,
+  ClientSessionOptions,
 } from '../../core/transport/types.js';
-import { UIMessageCodec } from '../codec/index.js';
+import { UIMessageCodec, type VercelInput, type VercelOutput, type VercelProjection } from '../codec/index.js';
 
-/** Core client transport options with Vercel AI SDK types pre-applied. */
-type CoreClientOpts = ClientTransportOptions<AI.UIMessageChunk, AI.UIMessage>;
+/** Core client session options with Vercel AI SDK types pre-applied. */
+type CoreClientOpts = ClientSessionOptions<VercelInput, VercelOutput, VercelProjection, AI.UIMessage>;
 
-/** Options for creating a Vercel client transport. Same as core options but without the codec field, and with `api` optional (defaults to `"/api/chat"`). */
-export type VercelClientTransportOptions = Omit<CoreClientOpts, 'codec' | 'api'> & Partial<Pick<CoreClientOpts, 'api'>>;
+/** Options for creating a Vercel client session. Same as core options but without the codec field. */
+export type VercelClientSessionOptions = Omit<CoreClientOpts, 'codec'>;
 
-/** Options for creating a Vercel server transport. Same as core options but without the codec field. */
-export type VercelServerTransportOptions = Omit<ServerTransportOptions<AI.UIMessageChunk, AI.UIMessage>, 'codec'>;
-
-export const DEFAULT_VERCEL_API = '/api/chat';
+/** Options for creating a Vercel agent session. Same as core options but without the codec field. */
+export type VercelAgentSessionOptions = Omit<
+  AgentSessionOptions<VercelInput, VercelOutput, VercelProjection, AI.UIMessage>,
+  'codec'
+>;
 
 /**
- * Create a client-side transport pre-configured with the Vercel AI SDK codec.
+ * Create a client-side session pre-configured with the Vercel AI SDK codec.
  *
- * Equivalent to calling the core `createClientTransport` with `codec: UIMessageCodec`.
- * @param options - Configuration for the client transport (codec is provided automatically).
- * @returns A new {@link ClientTransport} for Vercel AI SDK UIMessage/UIMessageChunk types.
+ * Equivalent to calling the core `createClientSession` with `codec: UIMessageCodec`.
+ * The core session is a pure Ably-channel transport — it never sends HTTP.
+ * To wake a serverless agent over HTTP, POST `run.toInvocation().toJSON()`
+ * yourself, or use `createChatTransport` (which does it for useChat parity).
+ * @param options - Configuration for the client session (codec is provided automatically).
+ * @returns A new {@link ClientSession} for Vercel AI SDK UIMessage/UIMessageChunk types.
  */
-export const createClientTransport = (
-  options: VercelClientTransportOptions,
-): ClientTransport<AI.UIMessageChunk, AI.UIMessage> =>
-  createCoreClientTransport({
-    ...options,
-    codec: UIMessageCodec,
-    // Mirrors the Vercel AI SDK's DefaultChatTransport default.
-    api: options.api ?? DEFAULT_VERCEL_API,
-  });
+export const createClientSession = (
+  options: VercelClientSessionOptions,
+): ClientSession<VercelInput, VercelOutput, VercelProjection, AI.UIMessage> =>
+  createCoreClientSession({ ...options, codec: UIMessageCodec });
 
 /**
- * Create a server-side transport pre-configured with the Vercel AI SDK codec.
+ * Create an agent (server-side) session pre-configured with the Vercel AI SDK codec.
  *
- * Equivalent to calling the core `createServerTransport` with `codec: UIMessageCodec`.
- * @param options - Configuration for the server transport (codec is provided automatically).
- * @returns A new {@link ServerTransport} for Vercel AI SDK UIMessage/UIMessageChunk types.
+ * Equivalent to calling the core `createAgentSession` with `codec: UIMessageCodec`.
+ * @param options - Configuration for the agent session (codec is provided automatically).
+ * @returns A new {@link AgentSession} for Vercel AI SDK UIMessage/UIMessageChunk types.
  */
-export const createServerTransport = (
-  options: VercelServerTransportOptions,
-): ServerTransport<AI.UIMessageChunk, AI.UIMessage> => createCoreServerTransport({ ...options, codec: UIMessageCodec });
+export const createAgentSession = (
+  options: VercelAgentSessionOptions,
+): AgentSession<VercelOutput, VercelProjection, AI.UIMessage> =>
+  createCoreAgentSession({ ...options, codec: UIMessageCodec });

package/src/vercel/transport/run-output-stream.ts

@@ -0,0 +1,170 @@
+/**
+ * Vercel-owned per-run output stream.
+ *
+ * Builds the `ReadableStream<UIMessageChunk>` that `useChat` consumes by
+ * subscribing to the session Tree's `output` and `run` events for a single
+ * run. Streaming is a useChat-integration concern, so it lives in the Vercel
+ * layer rather than the generic core: the core Tree is the fan-out point, and
+ * this projects its events into the shape `useChat` expects.
+ *
+ * Close semantics — the stream the consumer reads ends when:
+ * - a **terminal chunk** (`finish` / `error` / `abort`) is folded for the run.
+ *   This is the signal `useChat`'s `sendAutomaticallyWhen` waits for, and it
+ *   fires even when the run merely *suspends* for a tool call (a tool-calls
+ *   `finish` ends the consumer stream while the core run stays alive in the
+ *   Tree for the continuation); or
+ * - the run reaches `run-end`, which is always terminal (safety net for a run
+ *   that ends without emitting a terminal chunk). A `run-suspend` keeps the
+ *   core run alive and does not close the consumer stream.
+ *
+ * It errors when the session emits a non-fatal `error` (e.g. channel
+ * continuity loss, or an agent-reported mid-run error), so the consumer's
+ * reader rejects rather than hanging.
+ */
+
+import * as Ably from 'ably';
+import type * as AI from 'ai';
+
+import type { ClientSession } from '../../core/transport/types.js';
+import { ErrorCode } from '../../errors.js';
+import type { VercelInput, VercelOutput, VercelProjection } from '../codec/index.js';
+
+type VercelSession = ClientSession<VercelInput, VercelOutput, VercelProjection, AI.UIMessage>;
+
+/**
+ * Whether a Vercel output chunk ends the consumer-facing stream. The terminal
+ * variants are `finish` (end of an LLM turn, including tool-calls), `error`,
+ * and `abort`.
+ * @param output - The decoded output chunk.
+ * @returns True when the chunk should close the consumer stream.
+ */
+const isTerminalChunk = (output: VercelOutput): boolean =>
+  output.type === 'finish' || output.type === 'error' || output.type === 'abort';
+
+/** A consumer-facing run output stream plus the handles to settle it externally. */
+export interface RunOutputStream {
+  /** The stream of decoded outputs for the run, as `useChat` consumes it. */
+  stream: ReadableStream<VercelOutput>;
+  /** Close the stream now (e.g. on local cancel). Idempotent. */
+  close: () => void;
+  /** Error the stream now (e.g. on a failed agent-invocation POST). Idempotent. */
+  error: (reason: Ably.ErrorInfo) => void;
+}
+
+/**
+ * Create a consumer-facing output stream for a send, sourced from the session
+ * Tree's events. See the module docs for close/error semantics. The returned
+ * `close`/`error` let the caller settle the stream for conditions the Tree
+ * doesn't surface (local cancel, POST failure).
+ *
+ * Outputs route PURELY by the triggering input's codec-message-id — the key the
+ * client owns from send time, before the agent mints the runId. The agent's
+ * minted runId is supplied as a promise so the run-end safety-net can still
+ * close the stream once it resolves.
+ * @param session - The Vercel client session whose Tree to observe.
+ * @param runId - The agent-minted runId, resolved when run-start is observed.
+ *   Used only by the run-end safety-net; routing keys on `inputCodecMessageId`.
+ * @param inputCodecMessageId - The triggering input's codec-message-id. An
+ *   output routes to this stream when it carries this id.
+ * @returns The stream and its external settle handles.
+ */
+export const createRunOutputStream = (
+  session: VercelSession,
+  runId: Promise<string>,
+  inputCodecMessageId: string,
+): RunOutputStream => {
+  const holder: { controller?: ReadableStreamDefaultController<VercelOutput> } = {};
+  // ReadableStream's start() runs synchronously, so the controller is captured
+  // before the constructor returns.
+  const unsubscribe: (() => void)[] = [];
+  const stream = new ReadableStream<VercelOutput>({
+    start: (controller) => {
+      holder.controller = controller;
+    },
+    cancel: () => {
+      teardown();
+    },
+  });
+  const { controller } = holder;
+  if (!controller) {
+    throw new Ably.ErrorInfo(
+      'unable to create run stream; ReadableStream start() was not called synchronously',
+      ErrorCode.SessionSubscriptionError,
+      500,
+    );
+  }
+
+  // The agent mints the runId; learn it (for the run-end safety-net) when the
+  // promise resolves. Fire-and-forget: the stream opens on the input key, so a
+  // never-resolving runId only forgoes the safety-net, not normal close.
+  let resolvedRunId: string | undefined;
+  // Best-effort: failure only disables the run-end safety-net; normal close is
+  // the terminal chunk. `void` discards the promise (no await needed here).
+  void runId.then(
+    (id) => {
+      resolvedRunId = id;
+    },
+    () => {
+      /* session closed before run-start; safety-net stays disarmed */
+    },
+  );
+
+  let settled = false;
+  const teardown = (): void => {
+    for (const unsub of unsubscribe) unsub();
+    unsubscribe.length = 0;
+  };
+  // Settle the stream at most once: run the controller action (close/error),
+  // swallow the throw if the consumer already cancelled, then tear down.
+  const settle = (action: () => void): void => {
+    if (settled) return;
+    settled = true;
+    try {
+      action();
+    } catch {
+      /* consumer already cancelled the stream */
+    }
+    teardown();
+  };
+  const close = (): void => {
+    settle(() => {
+      controller.close();
+    });
+  };
+  const error = (reason: Ably.ErrorInfo): void => {
+    settle(() => {
+      controller.error(reason);
+    });
+  };
+
+  unsubscribe.push(
+    session.tree.on('output', (event) => {
+      if (event.inputCodecMessageId !== inputCodecMessageId) return;
+      for (const output of event.events) {
+        try {
+          controller.enqueue(output);
+        } catch {
+          close();
+          return;
+        }
+        if (isTerminalChunk(output)) {
+          close();
+          return;
+        }
+      }
+    }),
+    session.tree.on('run', (event) => {
+      // run-end is always terminal; a run-suspend (event.type === 'suspend')
+      // keeps the core run alive and must not close the consumer stream. Match
+      // against the resolved runId once the agent has minted it.
+      if (event.type === 'end' && resolvedRunId !== undefined && event.runId === resolvedRunId) {
+        close();
+      }
+    }),
+    session.on('error', (reason) => {
+      error(reason);
+    }),
+  );
+
+  return { stream, close, error };
+};

package/src/version.ts

@@ -0,0 +1,2 @@
+/** SDK version. Kept in sync with `package.json` by the `/release` workflow. */
+export const VERSION = '0.2.0';

package/dist/core/transport/client-transport.d.ts

@@ -1,10 +0,0 @@
-import { ClientTransport, ClientTransportOptions } from './types.js';
-/**
- * Create a client-side transport that manages conversation state over an Ably channel.
- *
- * Subscribes to the channel immediately (before attach per RTL7g). The caller should
- * ensure the channel is attached or will be attached shortly after creation.
- * @param options - Configuration for the client transport.
- * @returns A new {@link ClientTransport} instance.
- */
-export declare const createClientTransport: <TEvent, TMessage>(options: ClientTransportOptions<TEvent, TMessage>) => ClientTransport<TEvent, TMessage>;

package/dist/core/transport/decode-history.d.ts

@@ -1,43 +0,0 @@
-import { Logger } from '../../logger.js';
-import { Codec } from '../codec/types.js';
-import { HistoryPage, LoadHistoryOptions } from './types.js';
-/**
- * decodeHistory — load conversation history from an Ably channel and
- * return decoded messages as a paginated HistoryPage result.
- *
- * Uses a fresh decoder (not shared with the live subscription) to avoid
- * state conflicts. Per-turn accumulators handle interleaved turns correctly.
- *
- * The `limit` option controls the number of **messages** returned,
- * not the number of Ably wire messages fetched. The implementation pages
- * back through Ably history until `limit` complete messages have
- * been assembled. Partial turns (incomplete at the page boundary) are
- * buffered internally and completed when `next()` fetches more pages.
- *
- * Only completed messages appear in `items`. A message is complete when
- * its terminal event (finish/abort/error) has been received.
- *
- * Because Ably history returns newest-first while the decoder requires
- * chronological order, all collected Ably messages are re-decoded from
- * oldest to newest at the point a result is built. This handles turns
- * that span page boundaries correctly. The fetch loop uses a cheap
- * header-based completion counter to decide when to stop paging, so the
- * full decode runs exactly once per traversal regardless of page count.
- */
-import type * as Ably from 'ably';
-/**
- * Load conversation history from a channel and return decoded messages.
- *
- * Attaches the channel if not already attached, then calls
- * `channel.history({ untilAttach: true })` to guarantee no gap between
- * historical and live messages. The attach is idempotent.
- *
- * The `limit` option controls the number of complete messages
- * returned per page, not the number of Ably wire messages fetched.
- * @param channel - The Ably channel to load history from.
- * @param codec - The codec for decoding wire messages into domain messages.
- * @param options - Pagination options.
- * @param logger - Logger for diagnostic output.
- * @returns The first page of decoded history.
- */
-export declare const decodeHistory: <TEvent, TMessage>(channel: Ably.RealtimeChannel, codec: Codec<TEvent, TMessage>, options: LoadHistoryOptions | undefined, logger: Logger) => Promise<HistoryPage<TMessage>>;

package/dist/core/transport/server-transport.d.ts

@@ -1,7 +0,0 @@
-import { ServerTransport, ServerTransportOptions } from './types.js';
-/**
- * Create a server transport bound to the given channel and codec.
- * @param options - Transport configuration.
- * @returns A new {@link ServerTransport} instance.
- */
-export declare const createServerTransport: <TEvent, TMessage>(options: ServerTransportOptions<TEvent, TMessage>) => ServerTransport<TEvent, TMessage>;

package/dist/core/transport/stream-router.d.ts

@@ -1,29 +0,0 @@
-import { Logger } from '../../logger.js';
-/**
- * Client-side stream routing.
- *
- * Maintains a map of turnId to ReadableStreamController. Routes decoded events
- * to the correct stream. Closes streams on terminal events, explicit close, or
- * error.
- */
-import * as Ably from 'ably';
-/** Routes decoded events to the correct turn's ReadableStream. */
-export interface StreamRouter<TEvent> {
-    /** Register a new stream for a turnId. Returns the ReadableStream the consumer reads from. */
-    createStream(turnId: string): ReadableStream<TEvent>;
-    /** Close the stream for a turnId. Returns true if a stream existed. */
-    closeStream(turnId: string): boolean;
-    /** Error the stream for a turnId. The consumer's reader will reject with the given error. Returns true if a stream existed. */
-    errorStream(turnId: string, error: Ably.ErrorInfo): boolean;
-    /** Enqueue an event to the correct stream. Returns true if routed successfully. */
-    route(turnId: string, event: TEvent): boolean;
-    /** Whether a specific turnId has an active stream. */
-    has(turnId: string): boolean;
-}
-/**
- * Create a StreamRouter that routes decoded events to per-turn ReadableStreams.
- * @param isTerminal - Predicate that returns true for events that close the stream.
- * @param logger - Logger for diagnostic output.
- * @returns A new {@link StreamRouter} instance.
- */
-export declare const createStreamRouter: <TEvent>(isTerminal: (event: TEvent) => boolean, logger: Logger) => StreamRouter<TEvent>;

package/dist/core/transport/turn-manager.d.ts

@@ -1,37 +0,0 @@
-import { Logger } from '../../logger.js';
-import { TurnEndReason } from './types.js';
-/**
- * Server-side turn state management and lifecycle event publishing.
- *
- * Owns the authoritative turn lifecycle. Tracks active turns with their
- * AbortControllers and clientIds. Publishes turn-start and turn-end events
- * on the Ably channel so all clients can react to turn state changes.
- */
-import type * as Ably from 'ably';
-/** Manages active turns and publishes turn lifecycle events on the channel. */
-export interface TurnManager {
-    /** Register a new turn. Publishes turn-start on the channel. Returns AbortSignal. */
-    startTurn(turnId: string, clientId?: string, controller?: AbortController, metadata?: {
-        parent?: string;
-        forkOf?: string;
-    }): Promise<AbortSignal>;
-    /** End a turn. Publishes turn-end on the channel. Cleans up internal state. */
-    endTurn(turnId: string, reason: TurnEndReason): Promise<void>;
-    /** Get the AbortSignal for a turn. */
-    getSignal(turnId: string): AbortSignal | undefined;
-    /** Get the clientId that owns a turn. */
-    getClientId(turnId: string): string | undefined;
-    /** Abort the signal for a turn. */
-    abort(turnId: string): void;
-    /** Get all active turn IDs. */
-    getActiveTurnIds(): string[];
-    /** Abort all active turns and clear state. */
-    close(): void;
-}
-/**
- * Create a turn manager bound to the given channel.
- * @param channel - The Ably channel to publish lifecycle events on.
- * @param logger - Optional logger for diagnostic output.
- * @returns A new {@link TurnManager} instance.
- */
-export declare const createTurnManager: (channel: Ably.RealtimeChannel, logger?: Logger) => TurnManager;

package/dist/react/contexts/transport-context.d.ts

@@ -1,31 +0,0 @@
-import { ClientTransport } from '../../core/transport/types.js';
-import type * as Ably from 'ably';
-/**
- * A single entry in the transport registry, holding the transport and any
- * error that occurred during its construction.
- *
- * `transport` is `undefined` when construction failed.
- * `error` is set when `createClientTransport` threw during provider render.
- */
-export interface TransportSlot {
-    /** The constructed transport, or `undefined` if construction failed. */
-    transport: ClientTransport<unknown, unknown> | undefined;
-    /** Construction error from `createClientTransport`, or `undefined` on success. */
-    error: Ably.ErrorInfo | undefined;
-}
-/** The shape of the TransportContext value — a record of channelName → slot. */
-export type TransportContextValue = Readonly<Record<string, TransportSlot>>;
-/**
- * Context that holds the registered {@link ClientTransport} slots, keyed by channelName.
- * Each slot contains the transport (or `undefined` on construction failure) and any error.
- * Populated by {@link TransportProvider}; read by {@link useClientTransport}.
- */
-export declare const TransportContext: import('react').Context<Readonly<Record<string, TransportSlot>>>;
-/**
- * Context that holds the nearest (innermost) transport slot.
- * Each {@link TransportProvider} sets this to its own slot, so descendants
- * can access the nearest transport without knowing its channel name.
- * `undefined` when no provider is present.
- * Read by hooks whose `transport` argument is omitted.
- */
-export declare const NearestTransportContext: import('react').Context<TransportSlot | undefined>;

package/dist/react/contexts/transport-provider.d.ts

@@ -1,49 +0,0 @@
-import { PropsWithChildren, ReactNode } from 'react';
-import { ClientTransportOptions } from '../../core/transport/types.js';
-/**
- * Props for {@link TransportProvider}.
- *
- * All {@link ClientTransportOptions} except `channel` (managed internally) plus `channelName`.
- */
-export interface TransportProviderProps<TEvent, TMessage> extends Omit<ClientTransportOptions<TEvent, TMessage>, 'channel'>, PropsWithChildren {
-    /** The Ably channel name to subscribe to. Also used as the context registry key. */
-    channelName: string;
-}
-/**
- * Provide a {@link ClientTransport} to descendant components.
- *
- * Wraps children with Ably's `ChannelProvider` using `channelName`, creates a
- * transport from the resolved channel and the remaining options, and registers it
- * in `TransportContext` under `channelName`. Descendants call
- * {@link useClientTransport} with the same `channelName` to access the transport.
- *
- * If `createClientTransport` throws during construction, the error is surfaced
- * through `useClientTransport` as `transportError` — the component tree does not
- * crash and children are still rendered.
- *
- * ```tsx
- * <TransportProvider channelName="ai:demo" codec={UIMessageCodec}>
- *   <Chat />
- * </TransportProvider>
- *
- * // Inside Chat:
- * const { transport, transportError } = useClientTransport({ channelName: 'ai:demo' });
- * ```
- *
- * For multiple transports, nest providers with distinct channelNames:
- *
- * ```tsx
- * <TransportProvider channelName="ai:main" codec={UIMessageCodec}>
- *   <TransportProvider channelName="ai:aux" codec={UIMessageCodec}>
- *     <App />
- *   </TransportProvider>
- * </TransportProvider>
- *
- * // Inside App:
- * const { transport: main } = useClientTransport({ channelName: 'ai:main' });
- * const { transport: aux }  = useClientTransport({ channelName: 'ai:aux' });
- * ```
- * @param props - Provider configuration including `channelName`, `codec`, and all other {@link ClientTransportOptions}.
- * @returns A React element wrapping children with ChannelProvider and TransportContext.
- */
-export declare const TransportProvider: <TEvent, TMessage>(props: TransportProviderProps<TEvent, TMessage>) => ReactNode;

package/dist/react/create-transport-hooks.d.ts

@@ -1,124 +0,0 @@
-import { ComponentType } from 'react';
-import { ClientTransport, View } from '../core/transport/types.js';
-import { TransportProviderProps } from './contexts/transport-provider.js';
-import { ClientTransportHandle } from './use-client-transport.js';
-import { TreeHandle } from './use-tree.js';
-import { ViewHandle } from './use-view.js';
-/**
- * createTransportHooks: factory that captures TEvent and TMessage once and returns
- * a bundle of type-safe hooks + TransportProvider. Hook call sites need no type
- * parameters at every use — just call the hooks directly.
- * @example
- * // Once per app (e.g. in a shared transport.ts):
- * export const {
- *   TransportProvider,
- *   useClientTransport,
- *   useView,
- *   useActiveTurns,
- * } = createTransportHooks<UIMessageChunk, UIMessage>();
- *
- * // In page:
- * <TransportProvider channelName="ai:demo" codec={UIMessageCodec}>
- *   <Chat />
- * </TransportProvider>
- *
- * // In Chat — no type params needed, transport is implicit from nearest provider:
- * const { nodes } = useView({ limit: 30 });
- * const turns = useActiveTurns();
- */
-import type * as Ably from 'ably';
-/**
- * Bundle of type-safe hooks and provider returned by {@link createTransportHooks}.
- *
- * `TEvent` and `TMessage` are baked in at factory creation time so no type params
- * are needed at hook call sites.
- */
-export interface TransportHooks<TEvent, TMessage> {
-    /**
-     * `TransportProvider` narrowed to `TEvent`/`TMessage`. No JSX type params needed.
-     */
-    TransportProvider: ComponentType<TransportProviderProps<TEvent, TMessage>>;
-    /**
-     * Read the transport from context. No type params needed.
-     *
-     * Returns `{ transport, transportError }`. When no provider is found,
-     * `transportError` is set and `transport` is a stub that throws on access —
-     * the hook never throws during render.
-     *
-     * Pass `onError` to subscribe to post-construction transport errors
-     * (e.g. send failures, channel continuity loss) without wiring
-     * `transport.on('error', …)` manually.
-     */
-    useClientTransport: (props?: {
-        /** Channel name to look up; omit to use the nearest {@link TransportProvider}. */
-        channelName?: string;
-        /** When `true`, return a stub transport that throws on any access. */
-        skip?: boolean;
-        /** Called whenever the resolved transport emits an error event. */
-        onError?: (error: Ably.ErrorInfo) => void;
-    }) => ClientTransportHandle<TEvent, TMessage>;
-    /**
-     * Subscribe to the nearest transport's view and return the visible node list with pagination.
-     * Pass `transport` to use a transport's default view, `view` to subscribe to a specific view
-     * directly. Pass `limit` to auto-load on mount. Pass `skip: true` for an empty handle.
-     */
-    useView: (props?: {
-        /** Client transport whose default view to subscribe to; defaults to the nearest {@link TransportProvider}. */
-        transport?: ClientTransport<TEvent, TMessage> | null;
-        /** A specific {@link View} to subscribe to directly. Takes priority over `transport`. */
-        view?: View<TEvent, TMessage> | null;
-        /** When provided, auto-loads the first page on mount. */
-        limit?: number;
-        /** When `true`, skip all subscriptions and return an empty handle. */
-        skip?: boolean;
-    }) => ViewHandle<TEvent, TMessage>;
-    /**
-     * Track active turns across all clients on the channel.
-     * Pass `transport` to override; defaults to the nearest {@link TransportProvider}.
-     */
-    useActiveTurns: (props?: {
-        /** Override transport; defaults to the nearest {@link TransportProvider}. */
-        transport?: ClientTransport<TEvent, TMessage> | null;
-    }) => Map<string, Set<string>>;
-    /**
-     * Navigate conversation branches in the transport tree.
-     * Pass `transport` to override; defaults to the nearest {@link TransportProvider}.
-     */
-    useTree: (props?: {
-        /** Override transport; defaults to the nearest {@link TransportProvider}. */
-        transport?: ClientTransport<TEvent, TMessage>;
-    }) => TreeHandle<TMessage>;
-    /**
-     * Subscribe to raw Ably messages on the transport channel.
-     * Pass `transport` to override; defaults to the nearest {@link TransportProvider}.
-     * Pass `skip: true` to return an empty array without subscribing.
-     */
-    useAblyMessages: (props?: {
-        /** Override transport; defaults to the nearest {@link TransportProvider}. */
-        transport?: ClientTransport<TEvent, TMessage>;
-        /** When `true`, skip all subscriptions and return an empty array. */
-        skip?: boolean;
-    }) => Ably.InboundMessage[];
-    /**
-     * Create an independent view over the same tree.
-     * Pass `transport` to override; defaults to the nearest {@link TransportProvider}.
-     * Pass `skip: true` to return an empty handle without creating a view.
-     */
-    useCreateView: (props?: {
-        /** Override transport; defaults to the nearest {@link TransportProvider}. */
-        transport?: ClientTransport<TEvent, TMessage> | null;
-        /** When provided, auto-loads the first page on mount. */
-        limit?: number;
-        /** When `true`, skip view creation and return an empty handle. */
-        skip?: boolean;
-    }) => ViewHandle<TEvent, TMessage>;
-}
-/**
- * Create a bundle of type-safe hooks and provider for a given `TEvent`/`TMessage` pair.
- *
- * `TEvent` and `TMessage` are captured at factory creation time; hook call sites need
- * no type parameters. The returned hooks are thin wrappers around the standalone hooks
- * with the types resolved.
- * @returns A {@link TransportHooks} bundle.
- */
-export declare const createTransportHooks: <TEvent, TMessage>() => TransportHooks<TEvent, TMessage>;

package/dist/react/use-active-turns.d.ts

@@ -1,12 +0,0 @@
-import { ClientTransport } from '../core/transport/types.js';
-/**
- * Returns a reactive Map of all active turns on the channel, keyed by clientId.
- * Updates when turns start or end. When `transport` is omitted, uses the nearest
- * {@link TransportProvider}'s transport via context.
- * @param props - Options including optional `transport`.
- * @param props.transport - Transport to track turns for; defaults to the nearest provider.
- * @returns A Map where keys are clientIds and values are Sets of active turnIds.
- */
-export declare const useActiveTurns: <TEvent, TMessage>({ transport, }?: {
-    transport?: ClientTransport<TEvent, TMessage> | null;
-}) => Map<string, Set<string>>;