basalt-ui 1.40.3 → 2.0.0

package/dist/agent/thread.js

@@ -1,137 +1,6 @@
-import { useCallback, useRef } from "react";
-import { createPersistedState } from "../state.js";
-import { mintThreadId } from "./id.js";
-function createThreadsStore(opts) {
-  const maxThreads = opts.maxThreads ?? 50;
-  const maxMessages = opts.maxMessagesPerThread ?? 100;
-  const usePersistedThreads = createPersistedState({
-    key: opts.key,
-    version: opts.version,
-    initial: { threads: [], activeId: null }
-  });
-  return function useThreadsStore() {
-    const [state, setState] = usePersistedThreads();
-    const ref = useRef(state);
-    ref.current = state;
-    const commit = useCallback(
-      (next) => {
-        ref.current = next;
-        setState(next);
-      },
-      [setState]
-    );
-    const select = useCallback(
-      (id) => {
-        commit({ ...ref.current, activeId: id });
-      },
-      [commit]
-    );
-    const create = useCallback(
-      (createOpts) => {
-        const id = mintThreadId();
-        const now = Date.now();
-        const thread = {
-          id,
-          messages: [],
-          outcome: null,
-          status: "pending",
-          read: false,
-          createdAt: now,
-          updatedAt: now,
-          ...createOpts?.meta !== void 0 ? { meta: createOpts.meta } : {}
-        };
-        const threads = [thread, ...ref.current.threads];
-        const trimmed = threads.length > maxThreads ? threads.slice(0, maxThreads) : threads;
-        commit({ ...ref.current, threads: trimmed });
-        return id;
-      },
-      [commit]
-    );
-    const appendMessage = useCallback(
-      (id, message) => {
-        const threads = ref.current.threads.map((thread) => {
-          if (thread.id !== id) return thread;
-          const messages = [...thread.messages, message];
-          const trimmed = messages.length > maxMessages ? messages.slice(messages.length - maxMessages) : messages;
-          return { ...thread, messages: trimmed, updatedAt: Date.now() };
-        });
-        commit({ ...ref.current, threads });
-      },
-      [commit]
-    );
-    const setOutcome = useCallback(
-      (id, outcome) => {
-        const threads = ref.current.threads.map(
-          (thread) => thread.id === id ? { ...thread, outcome, updatedAt: Date.now() } : thread
-        );
-        commit({ ...ref.current, threads });
-      },
-      [commit]
-    );
-    const setStatus = useCallback(
-      (id, status) => {
-        const threads = ref.current.threads.map(
-          (thread) => thread.id === id ? { ...thread, status, updatedAt: Date.now() } : thread
-        );
-        commit({ ...ref.current, threads });
-      },
-      [commit]
-    );
-    const setResumeToken = useCallback(
-      (id, token) => {
-        const threads = ref.current.threads.map((thread) => {
-          if (thread.id !== id) return thread;
-          const { resumeToken: _resumeToken, ...rest } = thread;
-          return {
-            ...rest,
-            ...token !== void 0 ? { resumeToken: token } : {},
-            updatedAt: Date.now()
-          };
-        });
-        commit({ ...ref.current, threads });
-      },
-      [commit]
-    );
-    const markRead = useCallback(
-      (id) => {
-        const threads = ref.current.threads.map(
-          (thread) => thread.id === id ? { ...thread, read: true } : thread
-        );
-        commit({ ...ref.current, threads });
-      },
-      [commit]
-    );
-    const remove = useCallback(
-      (id) => {
-        const threads = ref.current.threads.filter((thread) => thread.id !== id);
-        const activeId = ref.current.activeId === id ? null : ref.current.activeId;
-        commit({ threads, activeId });
-      },
-      [commit]
-    );
-    const clear = useCallback(() => {
-      commit({ threads: [], activeId: null });
-    }, [commit]);
-    return {
-      threads: state.threads,
-      activeId: state.activeId,
-      select,
-      create,
-      appendMessage,
-      setOutcome,
-      setStatus,
-      setResumeToken,
-      markRead,
-      remove,
-      clear,
-      // localStorage resolves synchronously and swallows its own quota errors, so there is never
-      // a pending load to await nor a failure a caller could act on. See ./adapter for the async
-      // store where these two carry real information.
-      hydrated: true,
-      error: void 0
-    };
-  };
+function isLiveStatus(status) {
+  return status === "submitted" || status === "streaming";
 }
 export {
-  createThreadsStore
+  isLiveStatus
 };

package/dist/agent/transport.d.ts

@@ -1,38 +1,21 @@
 /**
- * AgentTransport — the injected seam between useAgentStream and a concrete backend client.
+ * AgentTransport — the injected seam between useAgentThreadRuns and a concrete backend client.
  *
- * The default transport path is Eden-native typed streaming (zero extra deps). The transport is
+ * The one shipped transport is `aiSdkTransport`. The transport is
  * generic over the part type and input shape so consumers can extend AgentPart with domain-specific
  * variants while keeping the hook interface unchanged.
  *
- * Eden #231 doctrine (critical): applying a t.Object/t.Union response schema to an Elysia
- * `async function*` stream route collapses the streamed union to `any` in Eden Treaty. The
- * server handler MUST declare `: AsyncGenerator<AgentPart>` explicitly and carry NO response
- * schema. See agent/rules/basalt-agent.md for the full rationale and mitigation.
- *
  * Stream resumption is an OPTIONAL seam: a transport emits a StartPart at the top of a run
  * carrying an opaque `resumeToken`, and implements the optional `resume` method to reconnect a
  * run after a disconnect (reload, network drop). basalt-ui ships only the client-side interface —
  * a concrete resumable backend (e.g. Redis-backed) is the consumer's responsibility. Transports
  * that don't support resumption simply omit `resume`.
  *
- * @example
- * // Server-side Elysia route (consumer's app — NOT basalt-ui):
- * app.post('/chat', async function* ({ body }): AsyncGenerator<AgentPart> {
- *   yield { type: 'text', text: 'Hello' }
- *   yield { type: 'text', text: ' world' }
- * })
- *
- * // Client-side wiring:
- * import { edenTransport } from 'basalt-ui/agent'
- * const transport = edenTransport<AgentPart>((input, signal) =>
- *   api.chat.post({ body: { message: input }, fetch: { signal } }),
- * )
  */
-import type { AgentPart, AgentPartDraft } from './parts.js';
+import type { AgentPartDraft } from './parts.js';
 /**
  * The injected transport seam. `stream(input, signal, ctx)` returns an async generator of parts.
- * Implement this interface for any backend — Eden, fetch-based SSE, AI SDK, or a mock.
+ * Implement this interface for any backend — fetch-based SSE, AI SDK, or a mock.
  *
  * The default `TPart` is `AgentPartDraft` (not `AgentPart`): transports yield DRAFTS — `id`
  * optional — and the consuming hooks (or `withPartIds`) normalize a draft into a fully-identified
@@ -46,7 +29,7 @@ import type { AgentPart, AgentPartDraft } from './parts.js';
  * transport MAY use `ctx.messageId` as its outbound message id instead of minting a fresh one. The
  * param is optional and appended last so an existing two-arg transport keeps compiling unchanged —
  * only `useAgentThreadRuns.start()`/`retry()` pass it; a bare `stream(input, signal)` call (e.g.
- * `useAgentStream`, a hand-rolled caller) omits it and a transport falls back to minting its own.
+ * a hand-rolled caller) omits it and a transport falls back to minting its own.
  *
  * @example
  * // Minimal mock transport for tests / playground:
@@ -61,7 +44,7 @@ export type AgentTransport<TPart = AgentPartDraft, TInput = string> = {
         readonly messageId: string;
     }) => AsyncGenerator<TPart>;
     /** Optional: resume a previously-started run from its resumeToken (see StartPart). Transports that don't support resumption simply omit this. */
-    resume?: (resumeToken: string, signal?: AbortSignal) => AsyncGenerator<TPart>;
+    resume?: ((resumeToken: string, signal?: AbortSignal) => AsyncGenerator<TPart>) | undefined;
 };
 /**
  * A transport whose replay is safe to run over an already-rendered turn. Implementing `resume`
@@ -85,50 +68,4 @@ export type ResumableAgentTransport<TPart = AgentPartDraft, TInput = string> = A
  * }
  */
 export declare function isResumable<TPart, TInput>(t: AgentTransport<TPart, TInput>): t is ResumableAgentTransport<TPart, TInput>;
-/**
- * Wraps a consumer's Eden async-generator call into an AgentTransport.
- *
- * The `call` parameter is the typed Eden client method — e.g. `api.chat.post`. Eden Treaty
- * resolves the streaming route as `AsyncGenerator<TPart>` when the server handler carries the
- * correct explicit return type annotation (no response schema — see Eden #231 doctrine).
- *
- * `stream(input, signal)` awaits the call, asserts no error, then yields from the data generator.
- * The optional AbortSignal is forwarded to the fetch layer via the `fetch: { signal }` option in
- * the Eden call (the consumer must pass it through — see example).
- *
- * The optional second argument, `resumeCall`, mirrors `call`'s shape but takes a `resumeToken`
- * instead of the original input — e.g. `api.chat.resume.post`. When provided, the returned
- * transport gets a `resume` method built the same way as `stream`. When omitted, the returned
- * object has NO `resume` key at all (not `resume: undefined`) — consumers that don't wire a
- * resumable backend get a transport that behaves exactly as before.
- *
- * `resumeCall` alone does NOT make the transport resumable per `isResumable` — pass
- * `{ idempotentReplay: true }` as the third argument to opt in EXPLICITLY once the server-side
- * `resumeCall` route is verified to re-emit every text/reasoning delta with an authoritative
- * `offset` (never a bare append). This is an opt-in, not an inference: a `resumeCall` whose deltas
- * aren't offset-accurate would double-render on replay if treated as resumable.
- *
- * @example
- * import { edenTransport, type AgentPart } from 'basalt-ui/agent'
- *
- * // api is the consumer's Eden treaty client (import from their own api-client module)
- * // The Eden call must forward `signal` so stop() aborts the in-flight request:
- * const transport = edenTransport<AgentPart>(
- *   (input, signal) => api.chat.post({ body: { message: input }, fetch: { signal } }),
- *   (resumeToken, signal) => api.chat.resume.post({ body: { resumeToken }, fetch: { signal } }),
- *   { idempotentReplay: true },
- * )
- *
- * // Wire into useAgentStream:
- * const { send, stop, parts, status } = useAgentStream({ transport })
- */
-export declare function edenTransport<TPart = AgentPart, TInput = string>(call: (input: TInput, signal?: AbortSignal) => Promise<{
-    data: AsyncGenerator<TPart> | null;
-    error: unknown;
-}>, resumeCall?: (resumeToken: string, signal?: AbortSignal) => Promise<{
-    data: AsyncGenerator<TPart> | null;
-    error: unknown;
-}>, options?: {
-    readonly idempotentReplay?: true;
-}): AgentTransport<TPart, TInput> | ResumableAgentTransport<TPart, TInput>;
 //# sourceMappingURL=transport.d.ts.map

package/dist/agent/transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/agent/transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAIxD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,cAAc,CAAC,KAAK,GAAG,cAAc,EAAE,MAAM,GAAG,MAAM,IAAI;IACpE,MAAM,EAAE,CACN,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,WAAW,EACpB,GAAG,CAAC,EAAE;QAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,KACjC,cAAc,CAAC,KAAK,CAAC,CAAA;IAC1B,iJAAiJ;IACjJ,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,cAAc,CAAC,KAAK,CAAC,CAAA;CAC9E,CAAA;AAID;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,CAAC,KAAK,GAAG,cAAc,EAAE,MAAM,GAAG,MAAM,IAAI,cAAc,CAC3F,KAAK,EACL,MAAM,CACP,GAAG;IACF,QAAQ,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,cAAc,CAAC,KAAK,CAAC,CAAA;IACrF,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAA;CAChC,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EACvC,CAAC,EAAE,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,GAC/B,CAAC,IAAI,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,CAK7C;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,aAAa,CAAC,KAAK,GAAG,SAAS,EAAE,MAAM,GAAG,MAAM,EAC9D,IAAI,EAAE,CACJ,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,WAAW,KACjB,OAAO,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,EACpE,UAAU,CAAC,EAAE,CACX,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,WAAW,KACjB,OAAO,CAAC;IAAE,IAAI,EAAE,cAAc,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,EACpE,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,IAAI,CAAA;CAAE,GAC7C,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,CAsBxE"}
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/agent/transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,cAAc,CAAC,KAAK,GAAG,cAAc,EAAE,MAAM,GAAG,MAAM,IAAI;IACpE,MAAM,EAAE,CACN,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,WAAW,EACpB,GAAG,CAAC,EAAE;QAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,KACjC,cAAc,CAAC,KAAK,CAAC,CAAA;IAC1B,iJAAiJ;IACjJ,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,cAAc,CAAC,KAAK,CAAC,CAAC,GAAG,SAAS,CAAA;CAC5F,CAAA;AAID;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,CAAC,KAAK,GAAG,cAAc,EAAE,MAAM,GAAG,MAAM,IAAI,cAAc,CAC3F,KAAK,EACL,MAAM,CACP,GAAG;IACF,QAAQ,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,cAAc,CAAC,KAAK,CAAC,CAAA;IACrF,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAA;CAChC,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EACvC,CAAC,EAAE,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,GAC/B,CAAC,IAAI,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,CAK7C"}

package/dist/agent/transport.js

@@ -1,24 +1,6 @@
 function isResumable(t) {
   return typeof t.resume === "function" && t.idempotentReplay === true;
 }
-function edenTransport(call, resumeCall, options) {
-  const stream = async function* (input, signal) {
-    const { data, error } = await call(input, signal);
-    if (error) throw error;
-    if (data === null) return;
-    yield* data;
-  };
-  if (resumeCall === void 0) return { stream };
-  const resume = async function* (resumeToken, signal) {
-    const { data, error } = await resumeCall(resumeToken, signal);
-    if (error) throw error;
-    if (data === null) return;
-    yield* data;
-  };
-  if (options?.idempotentReplay !== true) return { stream, resume };
-  return { stream, resume, idempotentReplay: true };
-}
 export {
-  edenTransport,
   isResumable
 };

package/dist/agent/use-agent-thread-runs.d.ts

@@ -1,24 +1,41 @@
+import type { AgentError } from './error.js';
 import type { PartLike } from './merge.js';
 import type { OutcomeResolver } from './outcome.js';
 import type { AgentPart } from './parts.js';
-import type { ThreadsStore } from './thread.js';
+import type { LiveRunStatus, ThreadsStore } from './thread.js';
 import type { AgentTransport } from './transport.js';
+import type { Telemetry } from '../telemetry.js';
 /**
- * The live stream state of a single thread's in-flight turn.
+ * The stream state of a single thread's most recent turn, while it is in flight or has failed.
  *
- * A thread only has an entry in the `runs` map while its turn is actively streaming — once a
- * turn finishes (success or error), its entry is deleted from the map (the outcome lives on the
- * persisted `AgentThread` instead). So `status` only ever holds `'streaming'`; there is no
- * `'done'`/`'idle'`/`'error'` to observe here.
+ * `status` mirrors AI SDK's `ChatStatus`: `'submitted'` from send until the first content part
+ * (text, reasoning or tool) arrives, then `'streaming'`, or `'error'` once the turn failed. A turn
+ * that settles successfully (or is stopped) has its entry deleted from the `runs` map — the
+ * outcome lives on the persisted `AgentThread` instead.
+ *
+ * A turn that FAILS keeps its entry — `status: 'error'`, `error` set, the parts received so far —
+ * until the next `start()`/`retry()` on that thread replaces it or `stop()` dismisses it. So
+ * `runs.has(id)` means "in flight or failed"; `run.status` alone says which, and
+ * `liveStatus={runs.get(id)?.status}` is correct for the chat rows (`'error'` is not live).
  *
  * @example
  * const state: ThreadRunState = { status: 'streaming', parts: [{ type: 'text', text: 'Hi' }] }
  */
 export type ThreadRunState<TPart = AgentPart> = {
-    /** Always `'streaming'` — see the type doc for why no other status is reachable here. */
-    readonly status: 'streaming';
+    /** `'submitted'` until the first content part arrives, then `'streaming'`. */
+    readonly status: LiveRunStatus;
     /** Accumulated parts from the current stream for this thread. */
     readonly parts: TPart[];
+    readonly error?: undefined;
+} | {
+    readonly status: 'error';
+    /**
+     * The parts received before the failure. Empty when the turn's final message already landed
+     * in the thread (a failure after `appendMessage`, e.g. in `resolveOutcome`), so the feed
+     * never renders the same content twice.
+     */
+    readonly parts: TPart[];
+    readonly error: AgentError;
 };
 export type UseAgentThreadRunsArgs<TPart = AgentPart> = {
     /**
@@ -41,18 +58,34 @@ export type UseAgentThreadRunsArgs<TPart = AgentPart> = {
      * Converts raw user input into the thread's part shape. Defaults to a single text part.
      * Required when TPart is not the default AgentPart union.
      */
-    readonly toUserParts?: (input: string) => TPart[];
+    readonly toUserParts?: ((input: string) => TPart[]) | undefined;
     /**
-     * Called when a turn's stream throws — never for an `AbortError` (an intentional stop()/
-     * supersede, not a failure worth surfacing). Fires from the SAME catch branch that sets
-     * `onFailureStatus` on the thread, so a caller wanting a toast/notification for a genuine
-     * transport error (a 409/503/401, argo's hermes-chat S19) no longer has to wrap every transport
-     * call in its own generator to intercept the throw — see `consumeAndFinalize`'s catch block.
+     * Called with the RAW thrown value when a turn's stream throws — never for the aborts this hook
+     * issues itself (`stop()`, supersede, unmount). An abort that comes from elsewhere (the
+     * transport, the network layer) is a failure and fires, as `kind: 'aborted'` on the run. Fires
+     * from the SAME catch branch that sets `onFailureStatus` on the thread, so a caller wanting a
+     * toast/notification for a genuine transport error (a 409/503/401, argo's hermes-chat S19) no
+     * longer has to wrap every transport call in its own generator to intercept the throw — see
+     * `consumeAndFinalize`'s catch block.
      */
-    readonly onError?: (info: {
+    readonly onError?: ((info: {
         readonly threadId: string;
         readonly error: unknown;
-    }) => void;
+    }) => void) | undefined;
+    /**
+     * Minimum ms between `runs` commits while a part stream is flowing — `useChat`'s stable
+     * `throttle` semantics: the first part commits immediately, later parts within the window are
+     * batched into one trailing commit. The `submitted → streaming` edge, a failure, the end of the
+     * stream and `stop()` never wait on it, so no final part is lost. Default `100`; `0` commits
+     * every part.
+     */
+    readonly throttle?: number | undefined;
+    /**
+     * Receives one `chat.turn` event when a turn completes or fails (V2-SPEC § 7); a `stop()`ped
+     * turn emits nothing. Omitted, it defaults to the enclosing `BasaltProvider`'s `telemetry` sink,
+     * and outside a provider nothing is delivered. A throwing sink never breaks the turn.
+     */
+    readonly telemetry?: Telemetry | undefined;
 };
 export type UseAgentThreadRunsReturn<TPart = AgentPart> = {
     /** Live stream state per thread id, for threads with a run in progress or just completed. */
@@ -78,21 +111,25 @@ export type UseAgentThreadRunsReturn<TPart = AgentPart> = {
      */
     readonly retry: (threadId: string) => void;
     /**
-     * Abort the in-flight stream for `threadId` (true no-op only if BOTH `controllersRef` and
-     * `runs` have nothing for it — i.e. the thread genuinely isn't live). Preserves whatever content
+     * Abort the in-flight stream for `threadId`. A no-op when the thread has no live run and no
+     * failed entry. Preserves whatever content
      * had already arrived: if the run had accumulated any parts, they're persisted as an assistant
      * ChatMessage with `finish: 'stopped'` (unless that message already landed — see finalizeStop),
      * then distilled into an outcome and the thread is settled to 'done'.
      *
-     * Defense-in-depth: if `runs` reports `threadId` as `'streaming'` but no controller is
-     * registered for it (a phantom entry — not reachable via any path in this hook today, since the
-     * unmount-cleanup effect and `finalizeStop` both tear down `controllersRef` and `runs` together,
-     * but guarded against here so nothing in this file can EVER wedge a thread the UI shows as live
-     * with no way to reach a terminal state), `stop()` still settles it instead of silently
-     * no-opping forever.
+     * A FAILED turn's entry (`status: 'error'`) has no controller: `stop()` just dismisses it and
+     * leaves the thread's `'error'` status alone. A turn that has already settled is a no-op.
+     *
+     * Defense-in-depth: if `runs` reports `threadId` as live but no run record exists for it (a
+     * phantom entry — not reachable via any path in this hook today, since the unmount-cleanup
+     * effect and `finalizeStop` both tear down the records and `runs` together), `stop()` still
+     * settles it, once, instead of silently no-opping forever.
      */
     readonly stop: (threadId: string) => void;
-    /** Abort every in-flight stream across all threads, settling each the same way stop() would. */
+    /**
+     * Abort every in-flight stream across all threads, settling each the same way stop() would, and
+     * dismiss every failed entry.
+     */
     readonly stopAll: () => void;
 };
 /**
@@ -106,5 +143,5 @@ export type UseAgentThreadRunsReturn<TPart = AgentPart> = {
  * start(threadB, 'What changed in the last release?')
  * // both stream concurrently; runs.get(threadA) / runs.get(threadB) update independently
  */
-export declare function useAgentThreadRuns<TPart extends PartLike = AgentPart>({ transport, store, resolveOutcome, toUserParts, onError, }: UseAgentThreadRunsArgs<TPart>): UseAgentThreadRunsReturn<TPart>;
+export declare function useAgentThreadRuns<TPart extends PartLike = AgentPart>({ transport, store, resolveOutcome, toUserParts, onError, throttle, telemetry, }: UseAgentThreadRunsArgs<TPart>): UseAgentThreadRunsReturn<TPart>;
 //# sourceMappingURL=use-agent-thread-runs.d.ts.map

package/dist/agent/use-agent-thread-runs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-agent-thread-runs.d.ts","sourceRoot":"","sources":["../../src/agent/use-agent-thread-runs.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,KAAK,EAAgB,eAAe,EAAE,MAAM,WAAW,CAAA;AAE9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,KAAK,EAA6B,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAIjD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,CAAC,KAAK,GAAG,SAAS,IAAI;IAC9C,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,CAAA;CACxB,CAAA;AAID,MAAM,MAAM,sBAAsB,CAAC,KAAK,GAAG,SAAS,IAAI;IACtD;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,SAAS,EACd,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,GAC7B,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAA;IACzD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,KAAK,CAAC,CAAA;IACnC,uFAAuF;IACvF,QAAQ,CAAC,cAAc,EAAE,eAAe,CAAC,KAAK,CAAC,CAAA;IAC/C;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,EAAE,CAAA;IACjD;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAA;CAC1F,CAAA;AAID,MAAM,MAAM,wBAAwB,CAAC,KAAK,GAAG,SAAS,IAAI;IACxD,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC,CAAA;IACzD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACzD;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1C;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACzC,gGAAgG;IAChG,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAC7B,CAAA;AA0RD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,SAAS,QAAQ,GAAG,SAAS,EAAE,EACrE,SAAS,EACT,KAAK,EACL,cAAc,EACd,WAAW,EACX,OAAO,GACR,EAAE,sBAAsB,CAAC,KAAK,CAAC,GAAG,wBAAwB,CAAC,KAAK,CAAC,CAsUjE"}
+{"version":3,"file":"use-agent-thread-runs.d.ts","sourceRoot":"","sources":["../../src/agent/use-agent-thread-runs.ts"],"names":[],"mappings":"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"}