@effect-uai/ui 0.0.0-stage → 0.17.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Betalyra Sociedade Unipessoal Lda.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -1,3 +1,65 @@
-# Temporary Holding Version
+# @effect-uai/ui
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Agentic UI primitives for effect-uai: state and streams, not components.
+
+Your agent runs on the server; your user watches it in a browser. This
+package is the part in between: the server projects its loop onto a small,
+resumable wire protocol, and the client folds that protocol into plain data
+any framework can render. Every piece is a small function you can read,
+replace, or skip.
+
+## Modules
+
+Server:
+
+- `Projection`: turns an effect-uai loop into `RunEvent`s
+  (`toRunEvents({ contract })`; the contract's tool schemas encode tool values).
+- `Run`: one operator per job. `start` (`run-started` first), `complete`
+  (one terminal last), `stopWhen` (stop on a signal), `failed` (an error as
+  `run-failed`), `sequence` (per-stream `seq`), `coalesce` (merge deltas).
+- `SseEncoding`: envelopes as Server-Sent Events on Effect's `Sse`
+  (`encode`, `decode`, `responseHeaders`, `lastEventId` for reconnects).
+
+Wire:
+
+- `RunEvent`: the event schemas, the `Envelope { streamId, seq, runId?, event }`
+  every frame is wrapped in, and branded `StreamId` / `RunId` / `InputId`.
+- `Input`: what a client sends. A preset (`Input.submit(text)`,
+  `Input.resolve(decisions)`), with typed app `data` via `Input.make(DataSchema)`;
+  any schema with an `id` works instead.
+- `UiContract`: optional types shared by server and client, from Schemas
+  only. The wire stays JSON; the client decodes each envelope once, so the
+  state holds typed values (a `Date` is a `Date`).
+
+```ts
+// shared: Schemas only, safe in the browser
+const ChatUi = UiContract.make({ tools: [GetWeather] })
+
+// client: the state is typed by the contract
+const chat = Atoms.thread({ contract: ChatUi, runtime, transport, busy: "block" })
+for (const b of thread.active?.blocks ?? [])
+  if (b.type === "tool" && b.name === "get_weather") b.output?.observedAt // Date
+```
+
+Client:
+
+- `RunView`, `Thread`: folds (`initial` + `step`) from envelopes to plain
+  data: one run, or a chat (messages, the active run, pending inputs).
+- `Client`: `sse`, `ndjson`, and `resumable` (reconnect from the last `seq`).
+- `Transport`: per run (`direct`, `durable`, `local`) or per session
+  (`session`: one stream per chat, the server queues messages).
+- `Atoms`: state on `effect/reactivity`. `make` / `thread` for per-run
+  transports, `session` / `sessionThread` for sessions. React reads them with
+  `@effect/atom-react`, plain JS with `AtomRegistry.subscribe`.
+
+The `direct-chat` and `durable-chat` recipes are a server and a page each;
+`examples/tanstack-start-chat` and `examples/foldkit-chat` are framework apps
+with typed tools.
+
+## Install
+
+```sh
+pnpm add @effect-uai/ui
+```
+
+ESM-only. Requires `effect@>=4.0.1` and `@effect-uai/core` as peers.

package/dist/Atoms.d.mts

@@ -0,0 +1,141 @@
+import { Envelope, Payloads, StreamId, Untyped } from "./RunEvent.mjs";
+import { a as Input, r as Draft, u as Sent } from "./Input-Cz-Kxusm.mjs";
+import { c as Thread } from "./Thread-CAXsjhpX.mjs";
+import { Durable, Session, Transport } from "./Transport.mjs";
+import { UiContract } from "./UiContract.mjs";
+import { Effect, Schema } from "effect";
+import { Atom } from "effect/reactivity";
+import { SecureRandom } from "effect/crypto";
+declare namespace Atoms_d_exports {
+  export { Busy, Decode, Options, Runtime, SessionOptions, make, session, sessionThread, thread };
+}
+/**
+ * What `submit` does while a run is in flight. `"block"` ignores the new
+ * input; `"stop-then-submit"` abandons the current run locally and starts
+ * the new one (in durable mode the server-side run keeps going).
+ */
+type Busy = "block" | "stop-then-submit";
+/**
+ * The atoms' runtime: the transport's services plus `SecureRandom` for
+ * input ids, e.g. `Atom.runtime(Layer.mergeAll(FetchHttpClient.layer,
+ * SecureRandom.layerWebCrypto))`. A test provides a seeded one.
+ */
+type Runtime<R, ER> = Atom.AtomRuntime<R | SecureRandom.SecureRandom, ER>;
+/** Turns a wire envelope into what `step` folds (a contract's `decode`). */
+type Decode<D> = (envelope: Envelope) => Effect.Effect<D, Schema.SchemaError>;
+type WithDecode<D> = [Envelope] extends [D] ? {
+  readonly decode?: Decode<D>;
+} : {
+  readonly decode: Decode<D>;
+};
+/**
+ * `I` is the app's input type. `submit` takes a draft of it (`id` optional);
+ * the transport receives it with the id assigned (`Input.Sent<I>`, a UUIDv7
+ * from `SecureRandom`). `D` is the envelope `step` folds: the wire envelope,
+ * or a contract's decoded one (then pass `decode`).
+ */
+type BaseOptions<I, S, E, R, ER, D> = {
+  readonly runtime: Runtime<R, ER>;
+  readonly transport: Transport<Sent<I>, S, E, R>;
+  readonly initial: S;
+  readonly step: (state: S, envelope: D) => S;
+  readonly busy: Busy;
+  readonly isBusy?: (state: S) => boolean;
+  /** Optimistic update applied before the request goes out. */
+  readonly submitted?: (state: S, input: Sent<I>) => S;
+  /** Applied when a run's stream ends without its terminal. */
+  readonly ended?: (state: S, reason: "stopped" | "disconnected") => S;
+};
+type Options<I, S, E, R, ER, D = Envelope> = BaseOptions<I, S, E, R, ER, D> & WithDecode<D>;
+declare const build: <I, S, E, R, ER, D>(options: BaseOptions<I, S, E, R, ER, D> & {
+  readonly decode: Decode<D>;
+}) => {
+  state: Atom.Writable<S, S>;
+  streamId: Atom.Writable<(string & import("effect/Brand").Brand<"StreamId">) | null, (string & import("effect/Brand").Brand<"StreamId">) | null>;
+  submit: Atom.AtomResultFn<Draft<I>, void, ER>;
+  /** The current run; `AtomRegistry.getResult` on it waits for the run to finish. */
+  run: Atom.AtomResultFn<Sent<I>, void, E | ER | Schema.SchemaError>;
+  stop: Atom.AtomResultFn<void, void, E | ER>;
+  /** Re-attach to a run (`{ streamId, after }`); set for durable transports. */
+  resume: Atom.AtomResultFn<{
+    readonly streamId: StreamId;
+    readonly after: number;
+  }, void, E | ER | Schema.SchemaError> | undefined;
+};
+type Built<I, S, E, R, ER> = ReturnType<typeof build<I, S, E, R, ER, unknown>>;
+/**
+ * State over a per-run transport: `state`, `submit`, `stop`, `run`, and
+ * `resume` when the transport can re-attach (`Transport.durable`,
+ * `durableHttp`), typed as present for those.
+ */
+declare function make<I, S, E, R, ER, D = Envelope>(options: Options<I, S, E, R, ER, D> & {
+  readonly transport: Durable<Sent<I>, S, E, R>;
+}): Omit<Built<I, S, E, R, ER>, "resume"> & {
+  readonly resume: NonNullable<Built<I, S, E, R, ER>["resume"]>;
+};
+declare function make<I, S, E, R, ER, D = Envelope>(options: Options<I, S, E, R, ER, D>): Built<I, S, E, R, ER>;
+type ThreadOptions<I, E, R, ER, P extends Payloads> = {
+  readonly runtime: Runtime<R, ER>;
+  readonly transport: Transport<Sent<I>, Thread<P>, E, R>;
+  readonly busy: Busy;
+  readonly initial?: Thread<P>;
+};
+/**
+ * `make` with the `Thread` preset: a message list plus the active run. Takes
+ * the `Input` preset, with or without typed `data`. With `contract`, the
+ * state is typed by it. For other entry types, spread a `Thread.make(config)`
+ * fold into `make`.
+ */
+declare function thread<I extends Input, E, R, ER, P extends Payloads>(options: ThreadOptions<I, E, R, ER, P> & {
+  readonly contract: UiContract<P>;
+}): Built<I, Thread<P>, E, R, ER>;
+declare function thread<I extends Input, E, R, ER>(options: ThreadOptions<I, E, R, ER, Untyped>): Built<I, Thread, E, R, ER>;
+type BaseSessionOptions<I, S, E, R, ER, D> = {
+  readonly runtime: Runtime<R, ER>;
+  readonly transport: Session<Sent<I>, S, E, R>;
+  readonly initial: S;
+  readonly step: (state: S, envelope: D) => S;
+  /** While true, `submit` ignores new input (the server may also refuse). */
+  readonly isBusy?: (state: S) => boolean;
+  /** Optimistic update applied before the input is sent. */
+  readonly submitted?: (state: S, input: Sent<I>) => S;
+  /** Applied when sending fails or the session's stream gives up. */
+  readonly ended?: (state: S, reason: "stopped" | "disconnected") => S;
+};
+type SessionOptions<I, S, E, R, ER, D = Envelope> = BaseSessionOptions<I, S, E, R, ER, D> & WithDecode<D>;
+declare const buildSession: <I, S, E, R, ER, D>(options: BaseSessionOptions<I, S, E, R, ER, D> & {
+  readonly decode: Decode<D>;
+}) => {
+  state: Atom.Writable<S, S>;
+  streamId: Atom.Writable<(string & import("effect/Brand").Brand<"StreamId">) | null, (string & import("effect/Brand").Brand<"StreamId">) | null>;
+  open: Atom.AtomResultFn<string & import("effect/Brand").Brand<"StreamId">, unknown, unknown>;
+  submit: Atom.AtomResultFn<Draft<I>, unknown, unknown>;
+  stop: Atom.AtomResultFn<void, void, E | ER>;
+};
+type BuiltSession<I, S, E, R, ER> = ReturnType<typeof buildSession<I, S, E, R, ER, unknown>>;
+/**
+ * State over a session transport. `open(streamId)` follows a session's
+ * stream from its start (e.g. a chat id kept across reloads). `submit` sends
+ * an input; without an open session the server starts one, which is then
+ * opened. Runs arrive on the followed stream, not as responses to `submit`.
+ */
+declare function session<I, S, E, R, ER, D = Envelope>(options: SessionOptions<I, S, E, R, ER, D>): BuiltSession<I, S, E, R, ER>;
+type SessionThreadOptions<I, E, R, ER, P extends Payloads> = {
+  readonly runtime: Runtime<R, ER>;
+  readonly transport: Session<Sent<I>, Thread<P>, E, R>;
+  readonly isBusy?: (thread: Thread<P>) => boolean;
+};
+/**
+ * `session` with the `Thread` preset. Input sent while a run is active, or
+ * echoed by the server (`input-accepted`), waits in `thread.pending`: the
+ * server queues it. Pass `isBusy` for a server that refuses instead. With
+ * `contract`, the state is typed by it. For other entry types, spread a
+ * `Thread.make(config)` fold into `session`.
+ */
+declare function sessionThread<I extends Input, E, R, ER, P extends Payloads>(options: SessionThreadOptions<I, E, R, ER, P> & {
+  readonly contract: UiContract<P>;
+}): BuiltSession<I, Thread<P>, E, R, ER>;
+declare function sessionThread<I extends Input, E, R, ER>(options: SessionThreadOptions<I, E, R, ER, Untyped>): BuiltSession<I, Thread, E, R, ER>;
+//#endregion
+export { Busy, Decode, Options, Runtime, SessionOptions, make, session, sessionThread, Atoms_d_exports as t, thread };
+//# sourceMappingURL=Atoms.d.mts.map

package/dist/Atoms.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Atoms.d.mts","names":[],"sources":["../src/Atoms.ts"],"mappings":"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"}

package/dist/Atoms.mjs

@@ -0,0 +1,132 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { withId } from "./Input.mjs";
+import { presetFor } from "./Thread.mjs";
+import { Effect, Exit, Option, Stream } from "effect";
+import { Atom } from "effect/reactivity";
+//#region src/Atoms.ts
+/**
+* Framework-neutral state over a transport, built on `effect/reactivity`.
+* Per-run transports: `make` takes any fold (`initial` + `step`), `thread`
+* is the `Thread` preset. Session transports: `session` and
+* `sessionThread`, likewise. React reads them with `@effect/atom-react` (`useAtomValue`,
+* `useAtomSet`), Vue and Solid with their official bindings, plain JS with
+* `AtomRegistry.subscribe`.
+*
+* With a `UiContract`, every envelope is decoded once on arrival, so the
+* state holds decoded payloads and is typed by the contract.
+*/
+var Atoms_exports = /* @__PURE__ */ __exportAll({
+	make: () => make,
+	session: () => session,
+	sessionThread: () => sessionThread,
+	thread: () => thread
+});
+const identity = Effect.succeed;
+const build = (options) => {
+	const state = Atom.make(options.initial).pipe(Atom.keepAlive);
+	const streamId = Atom.make(null).pipe(Atom.keepAlive);
+	const follow = (envelopes) => envelopes.pipe(Stream.runForEach((envelope) => options.decode(envelope).pipe(Effect.flatMap((decoded) => Atom.set(streamId, envelope.streamId).pipe(Effect.andThen(Atom.update(state, (s) => options.step(s, decoded))))))), Effect.onExit((exit) => {
+		const ended = options.ended;
+		if (Exit.isSuccess(exit) || ended === void 0) return Effect.void;
+		const reason = Exit.hasInterrupts(exit) ? "stopped" : "disconnected";
+		return Atom.update(state, (s) => ended(s, reason));
+	}));
+	const run = options.runtime.fn()((input) => Effect.gen(function* () {
+		const submitted = options.submitted;
+		if (submitted !== void 0) yield* Atom.update(state, (s) => submitted(s, input));
+		yield* follow(options.transport.start(input, yield* Atom.get(state)));
+	})).pipe(Atom.keepAlive);
+	const submit = options.runtime.fn()((draft) => Effect.gen(function* () {
+		if (options.busy === "block" && options.isBusy?.(yield* Atom.get(state)) === true) return;
+		const input = yield* withId(draft);
+		yield* Atom.set(run, input);
+	}), { concurrent: true }).pipe(Atom.keepAlive);
+	const stop = options.runtime.fn()(() => Effect.gen(function* () {
+		const id = yield* Atom.get(streamId);
+		const serverStop = options.transport.stop;
+		if (serverStop !== void 0 && id !== null) return yield* serverStop(id);
+		yield* Atom.set(run, Atom.Interrupt);
+	})).pipe(Atom.keepAlive);
+	const resume = options.transport.resume;
+	return {
+		state,
+		streamId,
+		submit,
+		/** The current run; `AtomRegistry.getResult` on it waits for the run to finish. */
+		run,
+		stop,
+		/** Re-attach to a run (`{ streamId, after }`); set for durable transports. */
+		resume: resume === void 0 ? void 0 : options.runtime.fn()((arg) => follow(resume(arg.streamId, arg.after))).pipe(Atom.keepAlive)
+	};
+};
+function make(options) {
+	return build({
+		...options,
+		decode: options.decode ?? identity
+	});
+}
+function thread(options) {
+	const fold = presetFor();
+	return build({
+		runtime: options.runtime,
+		transport: options.transport,
+		busy: options.busy,
+		initial: options.initial ?? fold.initial,
+		step: fold.step,
+		decode: options.contract?.decode ?? identity,
+		isBusy: (t) => t.active !== null,
+		submitted: (t, input) => fold.submitted(t, input),
+		ended: fold.ended
+	});
+}
+const buildSession = (options) => {
+	const state = Atom.make(options.initial).pipe(Atom.keepAlive);
+	const streamId = Atom.make(null).pipe(Atom.keepAlive);
+	const settle = (exit) => {
+		const ended = options.ended;
+		return ended === void 0 || Exit.isSuccess(exit) || Exit.hasInterrupts(exit) ? Effect.void : Atom.update(state, (s) => ended(s, "disconnected"));
+	};
+	const open = options.runtime.fn()((id) => Atom.set(streamId, id).pipe(Effect.andThen(options.transport.events(id, 0).pipe(Stream.runForEach((envelope) => options.decode(envelope).pipe(Effect.flatMap((decoded) => Atom.update(state, (s) => options.step(s, decoded))))))), Effect.onExit(settle))).pipe(Atom.keepAlive);
+	return {
+		state,
+		streamId,
+		open,
+		submit: options.runtime.fn()((draft) => Effect.gen(function* () {
+			if (options.isBusy?.(yield* Atom.get(state)) === true) return;
+			const input = yield* withId(draft);
+			const submitted = options.submitted;
+			if (submitted !== void 0) yield* Atom.update(state, (s) => submitted(s, input));
+			const opened = Option.fromNullishOr(yield* Atom.get(streamId));
+			const sent = yield* options.transport.send(opened, input, yield* Atom.get(state));
+			if (Option.isNone(opened)) yield* Atom.set(open, sent);
+		}).pipe(Effect.onExit(settle)), { concurrent: true }).pipe(Atom.keepAlive),
+		stop: options.runtime.fn()(() => Effect.gen(function* () {
+			const id = yield* Atom.get(streamId);
+			const serverStop = options.transport.stop;
+			if (serverStop !== void 0 && id !== null) yield* serverStop(id);
+		})).pipe(Atom.keepAlive)
+	};
+};
+function session(options) {
+	return buildSession({
+		...options,
+		decode: options.decode ?? identity
+	});
+}
+function sessionThread(options) {
+	const fold = presetFor();
+	return buildSession({
+		runtime: options.runtime,
+		transport: options.transport,
+		initial: fold.initial,
+		step: fold.step,
+		decode: options.contract?.decode ?? identity,
+		...options.isBusy !== void 0 ? { isBusy: options.isBusy } : {},
+		submitted: (t, input) => fold.submitted(t, input),
+		ended: fold.ended
+	});
+}
+//#endregion
+export { make, session, sessionThread, Atoms_exports as t, thread };
+
+//# sourceMappingURL=Atoms.mjs.map

package/dist/Atoms.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Atoms.mjs","names":["Input.withId","Thread.presetFor"],"sources":["../src/Atoms.ts"],"sourcesContent":["/**\n * Framework-neutral state over a transport, built on `effect/reactivity`.\n * Per-run transports: `make` takes any fold (`initial` + `step`), `thread`\n * is the `Thread` preset. Session transports: `session` and\n * `sessionThread`, likewise. React reads them with `@effect/atom-react` (`useAtomValue`,\n * `useAtomSet`), Vue and Solid with their official bindings, plain JS with\n * `AtomRegistry.subscribe`.\n *\n * With a `UiContract`, every envelope is decoded once on arrival, so the\n * state holds decoded payloads and is typed by the contract.\n */\nimport { Effect, Exit, Option, type Schema, Stream } from \"effect\"\nimport type { SecureRandom } from \"effect/crypto\"\nimport { Atom } from \"effect/reactivity\"\nimport * as Input from \"./Input.js\"\nimport type { Envelope, Payloads, StreamId, Untyped } from \"./RunEvent.js\"\nimport * as Thread from \"./Thread.js\"\nimport type * as Transport from \"./Transport.js\"\nimport type { UiContract } from \"./UiContract.js\"\n\n/**\n * What `submit` does while a run is in flight. `\"block\"` ignores the new\n * input; `\"stop-then-submit\"` abandons the current run locally and starts\n * the new one (in durable mode the server-side run keeps going).\n */\nexport type Busy = \"block\" | \"stop-then-submit\"\n\n/**\n * The atoms' runtime: the transport's services plus `SecureRandom` for\n * input ids, e.g. `Atom.runtime(Layer.mergeAll(FetchHttpClient.layer,\n * SecureRandom.layerWebCrypto))`. A test provides a seeded one.\n */\nexport type Runtime<R, ER> = Atom.AtomRuntime<R | SecureRandom.SecureRandom, ER>\n\n/** Turns a wire envelope into what `step` folds (a contract's `decode`). */\nexport type Decode<D> = (envelope: Envelope) => Effect.Effect<D, Schema.SchemaError>\n\n// `decode` may be left out only when `step` folds wire envelopes.\ntype WithDecode<D> = [Envelope] extends [D]\n  ? { readonly decode?: Decode<D> }\n  : { readonly decode: Decode<D> }\n\n/**\n * `I` is the app's input type. `submit` takes a draft of it (`id` optional);\n * the transport receives it with the id assigned (`Input.Sent<I>`, a UUIDv7\n * from `SecureRandom`). `D` is the envelope `step` folds: the wire envelope,\n * or a contract's decoded one (then pass `decode`).\n */\ntype BaseOptions<I, S, E, R, ER, D> = {\n  readonly runtime: Runtime<R, ER>\n  readonly transport: Transport.Transport<Input.Sent<I>, S, E, R>\n  readonly initial: S\n  readonly step: (state: S, envelope: D) => S\n  readonly busy: Busy\n  readonly isBusy?: (state: S) => boolean\n  /** Optimistic update applied before the request goes out. */\n  readonly submitted?: (state: S, input: Input.Sent<I>) => S\n  /** Applied when a run's stream ends without its terminal. */\n  readonly ended?: (state: S, reason: \"stopped\" | \"disconnected\") => S\n}\n\nexport type Options<I, S, E, R, ER, D = Envelope> = BaseOptions<I, S, E, R, ER, D> & WithDecode<D>\n\nconst identity: Decode<Envelope> = Effect.succeed\n\nconst build = <I, S, E, R, ER, D>(\n  options: BaseOptions<I, S, E, R, ER, D> & { readonly decode: Decode<D> },\n) => {\n  const state = Atom.make(options.initial).pipe(Atom.keepAlive)\n  const streamId = Atom.make<StreamId | null>(null).pipe(Atom.keepAlive)\n\n  const follow = (envelopes: Stream.Stream<Envelope, E, R>) =>\n    envelopes.pipe(\n      Stream.runForEach((envelope) =>\n        options\n          .decode(envelope)\n          .pipe(\n            Effect.flatMap((decoded) =>\n              Atom.set(streamId, envelope.streamId).pipe(\n                Effect.andThen(Atom.update(state, (s) => options.step(s, decoded))),\n              ),\n            ),\n          ),\n      ),\n      Effect.onExit((exit) => {\n        const ended = options.ended\n        if (Exit.isSuccess(exit) || ended === undefined) return Effect.void\n        const reason = Exit.hasInterrupts(exit) ? \"stopped\" : \"disconnected\"\n        return Atom.update(state, (s) => ended(s, reason))\n      }),\n    )\n\n  // Writing to a non-concurrent `Atom.fn` interrupts its previous run, so the\n  // streaming lives in `run` and `submit` is a concurrent gate that applies\n  // the busy policy before anything is interrupted. Every fn atom is kept\n  // alive: an unobserved one is disposed, which interrupts its fiber.\n  const run = options.runtime\n    .fn<Input.Sent<I>>()((input) =>\n      Effect.gen(function* () {\n        const submitted = options.submitted\n        if (submitted !== undefined) yield* Atom.update(state, (s) => submitted(s, input))\n        yield* follow(options.transport.start(input, yield* Atom.get(state)))\n      }),\n    )\n    .pipe(Atom.keepAlive)\n\n  const submit = options.runtime\n    .fn<Input.Draft<I>>()(\n      (draft) =>\n        Effect.gen(function* () {\n          const blocked =\n            options.busy === \"block\" && options.isBusy?.(yield* Atom.get(state)) === true\n          if (blocked) return\n          const input = yield* Input.withId(draft)\n          yield* Atom.set(run, input)\n        }),\n      { concurrent: true },\n    )\n    .pipe(Atom.keepAlive)\n\n  // Durable: ask the server (its `run-stopped` arrives on the stream).\n  // Direct: interrupt the request; `ended` settles the run locally.\n  const stop = options.runtime\n    .fn<void>()(() =>\n      Effect.gen(function* () {\n        const id = yield* Atom.get(streamId)\n        const serverStop = options.transport.stop\n        if (serverStop !== undefined && id !== null) return yield* serverStop(id)\n        yield* Atom.set(run, Atom.Interrupt)\n      }),\n    )\n    .pipe(Atom.keepAlive)\n\n  const resume = options.transport.resume\n  const attach =\n    resume === undefined\n      ? undefined\n      : options.runtime\n          .fn<{ readonly streamId: StreamId; readonly after: number }>()((arg) =>\n            follow(resume(arg.streamId, arg.after)),\n          )\n          .pipe(Atom.keepAlive)\n\n  return {\n    state,\n    streamId,\n    submit,\n    /** The current run; `AtomRegistry.getResult` on it waits for the run to finish. */\n    run,\n    stop,\n    /** Re-attach to a run (`{ streamId, after }`); set for durable transports. */\n    resume: attach,\n  }\n}\n\ntype Built<I, S, E, R, ER> = ReturnType<typeof build<I, S, E, R, ER, unknown>>\n\n/**\n * State over a per-run transport: `state`, `submit`, `stop`, `run`, and\n * `resume` when the transport can re-attach (`Transport.durable`,\n * `durableHttp`), typed as present for those.\n */\nexport function make<I, S, E, R, ER, D = Envelope>(\n  options: Options<I, S, E, R, ER, D> & {\n    readonly transport: Transport.Durable<Input.Sent<I>, S, E, R>\n  },\n): Omit<Built<I, S, E, R, ER>, \"resume\"> & {\n  readonly resume: NonNullable<Built<I, S, E, R, ER>[\"resume\"]>\n}\nexport function make<I, S, E, R, ER, D = Envelope>(\n  options: Options<I, S, E, R, ER, D>,\n): Built<I, S, E, R, ER>\nexport function make<I, S, E, R, ER>(\n  options: Options<I, S, E, R, ER, Envelope>,\n): Built<I, S, E, R, ER> {\n  return build({ ...options, decode: options.decode ?? identity })\n}\n\ntype ThreadOptions<I, E, R, ER, P extends Payloads> = {\n  readonly runtime: Runtime<R, ER>\n  readonly transport: Transport.Transport<Input.Sent<I>, Thread.Thread<P>, E, R>\n  readonly busy: Busy\n  readonly initial?: Thread.Thread<P>\n}\n\n/**\n * `make` with the `Thread` preset: a message list plus the active run. Takes\n * the `Input` preset, with or without typed `data`. With `contract`, the\n * state is typed by it. For other entry types, spread a `Thread.make(config)`\n * fold into `make`.\n */\nexport function thread<I extends Input.Input, E, R, ER, P extends Payloads>(\n  options: ThreadOptions<I, E, R, ER, P> & { readonly contract: UiContract<P> },\n): Built<I, Thread.Thread<P>, E, R, ER>\nexport function thread<I extends Input.Input, E, R, ER>(\n  options: ThreadOptions<I, E, R, ER, Untyped>,\n): Built<I, Thread.Thread, E, R, ER>\n// The implementation sees `P` as `any`: the options both read and receive\n// `Thread<P>`, so no single `P` fits both overloads. Callers get the overloads.\nexport function thread<I extends Input.Input, E, R, ER>(\n  options: ThreadOptions<I, E, R, ER, any> & { readonly contract?: UiContract<any> },\n): Built<I, Thread.Thread<any>, E, R, ER> {\n  const fold = Thread.presetFor<any>()\n  return build({\n    runtime: options.runtime,\n    transport: options.transport,\n    busy: options.busy,\n    initial: options.initial ?? fold.initial,\n    step: fold.step,\n    decode: options.contract?.decode ?? identity,\n    isBusy: (t) => t.active !== null,\n    submitted: (t, input: Input.Sent<I>) => fold.submitted(t, input),\n    ended: fold.ended,\n  })\n}\n\n// ---------------------------------------------------------------------------\n// Sessions: one stream carries every run (a durable chat)\n// ---------------------------------------------------------------------------\n\ntype BaseSessionOptions<I, S, E, R, ER, D> = {\n  readonly runtime: Runtime<R, ER>\n  readonly transport: Transport.Session<Input.Sent<I>, S, E, R>\n  readonly initial: S\n  readonly step: (state: S, envelope: D) => S\n  /** While true, `submit` ignores new input (the server may also refuse). */\n  readonly isBusy?: (state: S) => boolean\n  /** Optimistic update applied before the input is sent. */\n  readonly submitted?: (state: S, input: Input.Sent<I>) => S\n  /** Applied when sending fails or the session's stream gives up. */\n  readonly ended?: (state: S, reason: \"stopped\" | \"disconnected\") => S\n}\n\nexport type SessionOptions<I, S, E, R, ER, D = Envelope> = BaseSessionOptions<I, S, E, R, ER, D> &\n  WithDecode<D>\n\nconst buildSession = <I, S, E, R, ER, D>(\n  options: BaseSessionOptions<I, S, E, R, ER, D> & { readonly decode: Decode<D> },\n) => {\n  const state = Atom.make(options.initial).pipe(Atom.keepAlive)\n  const streamId = Atom.make<StreamId | null>(null).pipe(Atom.keepAlive)\n\n  const settle = (exit: Exit.Exit<unknown, unknown>) => {\n    const ended = options.ended\n    return ended === undefined || Exit.isSuccess(exit) || Exit.hasInterrupts(exit)\n      ? Effect.void\n      : Atom.update(state, (s) => ended(s, \"disconnected\"))\n  }\n\n  // Non-concurrent: opening another session stops following the previous one.\n  const open = options.runtime\n    .fn<StreamId>()((id) =>\n      Atom.set(streamId, id).pipe(\n        Effect.andThen(\n          options.transport\n            .events(id, 0)\n            .pipe(\n              Stream.runForEach((envelope) =>\n                options\n                  .decode(envelope)\n                  .pipe(\n                    Effect.flatMap((decoded) =>\n                      Atom.update(state, (s) => options.step(s, decoded)),\n                    ),\n                  ),\n              ),\n            ),\n        ),\n        Effect.onExit(settle),\n      ),\n    )\n    .pipe(Atom.keepAlive)\n\n  const submit = options.runtime\n    .fn<Input.Draft<I>>()(\n      (draft) =>\n        Effect.gen(function* () {\n          if (options.isBusy?.(yield* Atom.get(state)) === true) return\n          const input = yield* Input.withId(draft)\n          const submitted = options.submitted\n          if (submitted !== undefined) yield* Atom.update(state, (s) => submitted(s, input))\n          const opened = Option.fromNullishOr(yield* Atom.get(streamId))\n          const sent = yield* options.transport.send(opened, input, yield* Atom.get(state))\n          if (Option.isNone(opened)) yield* Atom.set(open, sent)\n        }).pipe(Effect.onExit(settle)),\n      { concurrent: true },\n    )\n    .pipe(Atom.keepAlive)\n\n  // The server stops the active run; its `run-stopped` arrives on the stream.\n  const stop = options.runtime\n    .fn<void>()(() =>\n      Effect.gen(function* () {\n        const id = yield* Atom.get(streamId)\n        const serverStop = options.transport.stop\n        if (serverStop !== undefined && id !== null) yield* serverStop(id)\n      }),\n    )\n    .pipe(Atom.keepAlive)\n\n  return { state, streamId, open, submit, stop }\n}\n\ntype BuiltSession<I, S, E, R, ER> = ReturnType<typeof buildSession<I, S, E, R, ER, unknown>>\n\n/**\n * State over a session transport. `open(streamId)` follows a session's\n * stream from its start (e.g. a chat id kept across reloads). `submit` sends\n * an input; without an open session the server starts one, which is then\n * opened. Runs arrive on the followed stream, not as responses to `submit`.\n */\nexport function session<I, S, E, R, ER, D = Envelope>(\n  options: SessionOptions<I, S, E, R, ER, D>,\n): BuiltSession<I, S, E, R, ER>\nexport function session<I, S, E, R, ER>(\n  options: SessionOptions<I, S, E, R, ER, Envelope>,\n): BuiltSession<I, S, E, R, ER> {\n  return buildSession({ ...options, decode: options.decode ?? identity })\n}\n\ntype SessionThreadOptions<I, E, R, ER, P extends Payloads> = {\n  readonly runtime: Runtime<R, ER>\n  readonly transport: Transport.Session<Input.Sent<I>, Thread.Thread<P>, E, R>\n  readonly isBusy?: (thread: Thread.Thread<P>) => boolean\n}\n\n/**\n * `session` with the `Thread` preset. Input sent while a run is active, or\n * echoed by the server (`input-accepted`), waits in `thread.pending`: the\n * server queues it. Pass `isBusy` for a server that refuses instead. With\n * `contract`, the state is typed by it. For other entry types, spread a\n * `Thread.make(config)` fold into `session`.\n */\nexport function sessionThread<I extends Input.Input, E, R, ER, P extends Payloads>(\n  options: SessionThreadOptions<I, E, R, ER, P> & { readonly contract: UiContract<P> },\n): BuiltSession<I, Thread.Thread<P>, E, R, ER>\nexport function sessionThread<I extends Input.Input, E, R, ER>(\n  options: SessionThreadOptions<I, E, R, ER, Untyped>,\n): BuiltSession<I, Thread.Thread, E, R, ER>\n// `any` for `P` in the implementation only, as in `thread`.\nexport function sessionThread<I extends Input.Input, E, R, ER>(\n  options: SessionThreadOptions<I, E, R, ER, any> & { readonly contract?: UiContract<any> },\n): BuiltSession<I, Thread.Thread<any>, E, R, ER> {\n  const fold = Thread.presetFor<any>()\n  return buildSession({\n    runtime: options.runtime,\n    transport: options.transport,\n    initial: fold.initial,\n    step: fold.step,\n    decode: options.contract?.decode ?? identity,\n    ...(options.isBusy !== undefined ? { isBusy: options.isBusy } : {}),\n    submitted: (t, input: Input.Sent<I>) => fold.submitted(t, input),\n    ended: fold.ended,\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA+DA,MAAM,WAA6B,OAAO;AAE1C,MAAM,SACJ,YACG;CACH,MAAM,QAAQ,KAAK,KAAK,QAAQ,OAAO,CAAC,CAAC,KAAK,KAAK,SAAS;CAC5D,MAAM,WAAW,KAAK,KAAsB,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS;CAErE,MAAM,UAAU,cACd,UAAU,KACR,OAAO,YAAY,aACjB,QACG,OAAO,QAAQ,CAAC,CAChB,KACC,OAAO,SAAS,YACd,KAAK,IAAI,UAAU,SAAS,QAAQ,CAAC,CAAC,KACpC,OAAO,QAAQ,KAAK,OAAO,QAAQ,MAAM,QAAQ,KAAK,GAAG,OAAO,CAAC,CAAC,CACpE,CACF,CACF,CACJ,GACA,OAAO,QAAQ,SAAS;EACtB,MAAM,QAAQ,QAAQ;EACtB,IAAI,KAAK,UAAU,IAAI,KAAK,UAAU,KAAA,GAAW,OAAO,OAAO;EAC/D,MAAM,SAAS,KAAK,cAAc,IAAI,IAAI,YAAY;EACtD,OAAO,KAAK,OAAO,QAAQ,MAAM,MAAM,GAAG,MAAM,CAAC;CACnD,CAAC,CACH;CAMF,MAAM,MAAM,QAAQ,QACjB,GAAkB,CAAC,EAAE,UACpB,OAAO,IAAI,aAAa;EACtB,MAAM,YAAY,QAAQ;EAC1B,IAAI,cAAc,KAAA,GAAW,OAAO,KAAK,OAAO,QAAQ,MAAM,UAAU,GAAG,KAAK,CAAC;EACjF,OAAO,OAAO,QAAQ,UAAU,MAAM,OAAO,OAAO,KAAK,IAAI,KAAK,CAAC,CAAC;CACtE,CAAC,CACH,CAAC,CACA,KAAK,KAAK,SAAS;CAEtB,MAAM,SAAS,QAAQ,QACpB,GAAmB,CAAC,EAClB,UACC,OAAO,IAAI,aAAa;EAGtB,IADE,QAAQ,SAAS,WAAW,QAAQ,SAAS,OAAO,KAAK,IAAI,KAAK,CAAC,MAAM,MAC9D;EACb,MAAM,QAAQ,OAAOA,OAAa,KAAK;EACvC,OAAO,KAAK,IAAI,KAAK,KAAK;CAC5B,CAAC,GACH,EAAE,YAAY,KAAK,CACrB,CAAC,CACA,KAAK,KAAK,SAAS;CAItB,MAAM,OAAO,QAAQ,QAClB,GAAS,CAAC,OACT,OAAO,IAAI,aAAa;EACtB,MAAM,KAAK,OAAO,KAAK,IAAI,QAAQ;EACnC,MAAM,aAAa,QAAQ,UAAU;EACrC,IAAI,eAAe,KAAA,KAAa,OAAO,MAAM,OAAO,OAAO,WAAW,EAAE;EACxE,OAAO,KAAK,IAAI,KAAK,KAAK,SAAS;CACrC,CAAC,CACH,CAAC,CACA,KAAK,KAAK,SAAS;CAEtB,MAAM,SAAS,QAAQ,UAAU;CAUjC,OAAO;EACL;EACA;EACA;;EAEA;EACA;;EAEA,QAhBA,WAAW,KAAA,IACP,KAAA,IACA,QAAQ,QACL,GAA4D,CAAC,EAAE,QAC9D,OAAO,OAAO,IAAI,UAAU,IAAI,KAAK,CAAC,CACxC,CAAC,CACA,KAAK,KAAK,SAAS;CAW5B;AACF;AAmBA,SAAgB,KACd,SACuB;CACvB,OAAO,MAAM;EAAE,GAAG;EAAS,QAAQ,QAAQ,UAAU;CAAS,CAAC;AACjE;AAuBA,SAAgB,OACd,SACwC;CACxC,MAAM,OAAOC,UAAsB;CACnC,OAAO,MAAM;EACX,SAAS,QAAQ;EACjB,WAAW,QAAQ;EACnB,MAAM,QAAQ;EACd,SAAS,QAAQ,WAAW,KAAK;EACjC,MAAM,KAAK;EACX,QAAQ,QAAQ,UAAU,UAAU;EACpC,SAAS,MAAM,EAAE,WAAW;EAC5B,YAAY,GAAG,UAAyB,KAAK,UAAU,GAAG,KAAK;EAC/D,OAAO,KAAK;CACd,CAAC;AACH;AAsBA,MAAM,gBACJ,YACG;CACH,MAAM,QAAQ,KAAK,KAAK,QAAQ,OAAO,CAAC,CAAC,KAAK,KAAK,SAAS;CAC5D,MAAM,WAAW,KAAK,KAAsB,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS;CAErE,MAAM,UAAU,SAAsC;EACpD,MAAM,QAAQ,QAAQ;EACtB,OAAO,UAAU,KAAA,KAAa,KAAK,UAAU,IAAI,KAAK,KAAK,cAAc,IAAI,IACzE,OAAO,OACP,KAAK,OAAO,QAAQ,MAAM,MAAM,GAAG,cAAc,CAAC;CACxD;CAGA,MAAM,OAAO,QAAQ,QAClB,GAAa,CAAC,EAAE,OACf,KAAK,IAAI,UAAU,EAAE,CAAC,CAAC,KACrB,OAAO,QACL,QAAQ,UACL,OAAO,IAAI,CAAC,CAAC,CACb,KACC,OAAO,YAAY,aACjB,QACG,OAAO,QAAQ,CAAC,CAChB,KACC,OAAO,SAAS,YACd,KAAK,OAAO,QAAQ,MAAM,QAAQ,KAAK,GAAG,OAAO,CAAC,CACpD,CACF,CACJ,CACF,CACJ,GACA,OAAO,OAAO,MAAM,CACtB,CACF,CAAC,CACA,KAAK,KAAK,SAAS;CA6BtB,OAAO;EAAE;EAAO;EAAU;EAAM,QA3BjB,QAAQ,QACpB,GAAmB,CAAC,EAClB,UACC,OAAO,IAAI,aAAa;GACtB,IAAI,QAAQ,SAAS,OAAO,KAAK,IAAI,KAAK,CAAC,MAAM,MAAM;GACvD,MAAM,QAAQ,OAAOD,OAAa,KAAK;GACvC,MAAM,YAAY,QAAQ;GAC1B,IAAI,cAAc,KAAA,GAAW,OAAO,KAAK,OAAO,QAAQ,MAAM,UAAU,GAAG,KAAK,CAAC;GACjF,MAAM,SAAS,OAAO,cAAc,OAAO,KAAK,IAAI,QAAQ,CAAC;GAC7D,MAAM,OAAO,OAAO,QAAQ,UAAU,KAAK,QAAQ,OAAO,OAAO,KAAK,IAAI,KAAK,CAAC;GAChF,IAAI,OAAO,OAAO,MAAM,GAAG,OAAO,KAAK,IAAI,MAAM,IAAI;EACvD,CAAC,CAAC,CAAC,KAAK,OAAO,OAAO,MAAM,CAAC,GAC/B,EAAE,YAAY,KAAK,CACrB,CAAC,CACA,KAAK,KAAK,SAawB;EAAG,MAV3B,QAAQ,QAClB,GAAS,CAAC,OACT,OAAO,IAAI,aAAa;GACtB,MAAM,KAAK,OAAO,KAAK,IAAI,QAAQ;GACnC,MAAM,aAAa,QAAQ,UAAU;GACrC,IAAI,eAAe,KAAA,KAAa,OAAO,MAAM,OAAO,WAAW,EAAE;EACnE,CAAC,CACH,CAAC,CACA,KAAK,KAAK,SAE8B;CAAE;AAC/C;AAaA,SAAgB,QACd,SAC8B;CAC9B,OAAO,aAAa;EAAE,GAAG;EAAS,QAAQ,QAAQ,UAAU;CAAS,CAAC;AACxE;AAsBA,SAAgB,cACd,SAC+C;CAC/C,MAAM,OAAOC,UAAsB;CACnC,OAAO,aAAa;EAClB,SAAS,QAAQ;EACjB,WAAW,QAAQ;EACnB,SAAS,KAAK;EACd,MAAM,KAAK;EACX,QAAQ,QAAQ,UAAU,UAAU;EACpC,GAAI,QAAQ,WAAW,KAAA,IAAY,EAAE,QAAQ,QAAQ,OAAO,IAAI,CAAC;EACjE,YAAY,GAAG,UAAyB,KAAK,UAAU,GAAG,KAAK;EAC/D,OAAO,KAAK;CACd,CAAC;AACH"}

package/dist/Client-C9UYN_VK.d.mts

@@ -0,0 +1,219 @@
+import { Envelope } from "./RunEvent.mjs";
+import { Effect, Schedule, Schema, Stream } from "effect";
+import { Ndjson, Sse } from "effect/encoding";
+import { HttpClient, HttpClientError, HttpClientRequest } from "effect/http";
+declare namespace Client_d_exports {
+  export { ClientError, Disconnected, execute, ndjson, resumable, sse };
+}
+declare const Disconnected_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "Disconnected";
+} & Readonly<A>;
+/** The connection ended before the run's terminal event arrived. */
+declare class Disconnected extends Disconnected_base<{
+  readonly lastSeq: number;
+}> {}
+/** What an HTTP source can fail with: transport, a malformed SSE frame, or a malformed NDJSON line. */
+type ClientError = HttpClientError.HttpClientError | Schema.SchemaError | Sse.Retry | Sse.SseError | Ndjson.NdjsonError;
+/** Run a request, failing on a non-2xx status. */
+declare const execute: (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<import("effect/http/HttpClientResponse").HttpClientResponse, HttpClientError.HttpClientError, HttpClient.HttpClient>;
+/** An SSE response (`text/event-stream`) as envelopes. */
+declare const sse: (request: HttpClientRequest.HttpClientRequest) => Stream.Stream<Envelope, HttpClientError.HttpClientError | Sse.Retry | Schema.SchemaError | Sse.SseError, HttpClient.HttpClient>;
+/** An NDJSON response (one envelope per line) as envelopes. */
+declare const ndjson: (request: HttpClientRequest.HttpClientRequest) => Stream.Stream<{
+  readonly streamId: string & import("effect/Brand").Brand<"StreamId">;
+  readonly seq: number;
+  readonly runId?: (string & import("effect/Brand").Brand<"RunId">) | undefined;
+  readonly event: {
+    readonly type: "run-started";
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly name?: string | undefined;
+    readonly inputs: readonly (string & import("effect/Brand").Brand<"InputId">)[];
+    readonly protocol: 2;
+  } | {
+    readonly type: "run-failed";
+    readonly reason: string;
+    readonly message?: string | undefined;
+  } | {
+    readonly type: "run-stopped";
+  } | {
+    readonly type: "step-started";
+  } | {
+    readonly type: "step-finished";
+    readonly usage?: {
+      readonly input_tokens?: number | undefined;
+      readonly output_tokens?: number | undefined;
+      readonly total_tokens?: number | undefined;
+      readonly input_tokens_details?: {
+        readonly cached_tokens?: number | undefined;
+        readonly cache_write_tokens?: number | undefined;
+      } | undefined;
+      readonly output_tokens_details?: {
+        readonly reasoning_tokens?: number | undefined;
+      } | undefined;
+    } | undefined;
+  } | {
+    readonly type: "step-reset";
+  } | {
+    readonly type: "text-delta";
+    readonly text: string;
+  } | {
+    readonly type: "refusal-delta";
+    readonly text: string;
+  } | {
+    readonly type: "reasoning-started";
+  } | {
+    readonly type: "reasoning-delta";
+    readonly text: string;
+    readonly kind: "summary" | "trace";
+  } | {
+    readonly type: "citation";
+    readonly annotation: {
+      readonly type: "url_citation";
+      readonly url: string;
+      readonly title: string;
+      readonly start_index?: number | undefined;
+      readonly end_index?: number | undefined;
+      readonly cited_text?: string | undefined;
+      readonly marker?: number | undefined;
+    } | {
+      readonly type: "file_citation";
+      readonly file_id: string;
+      readonly index: number;
+    } | {
+      readonly type: "container_file_citation";
+      readonly container_id: string;
+      readonly file_id: string;
+      readonly start_index: number;
+      readonly end_index: number;
+    } | {
+      readonly type: "file_path";
+      readonly file_id: string;
+      readonly index: number;
+    };
+  } | {
+    readonly type: "image";
+    readonly image: import("@effect-uai/core/Image").ImageSource;
+    readonly partialIndex?: number | undefined;
+  } | {
+    readonly type: "object-started";
+    readonly id: string;
+    readonly name?: string | undefined;
+  } | {
+    readonly type: "object-delta";
+    readonly id: string;
+    readonly patch?: readonly ({
+      readonly op: "add";
+      readonly path: string;
+      readonly value: Schema.Json;
+    } | {
+      readonly op: "remove";
+      readonly path: string;
+    } | {
+      readonly op: "replace";
+      readonly path: string;
+      readonly value: Schema.Json;
+    })[] | undefined;
+    readonly value?: Schema.Json | undefined;
+  } | {
+    readonly type: "object-failed";
+    readonly id: string;
+    readonly issues: readonly {
+      readonly path: readonly (string | number)[];
+      readonly message: string;
+    }[];
+  } | {
+    readonly type: "tool-call-started";
+    readonly callId: string;
+    readonly name: string;
+  } | {
+    readonly type: "tool-call-args-delta";
+    readonly callId: string;
+    readonly delta: string;
+  } | {
+    readonly type: "usage";
+    readonly usage: {
+      readonly input_tokens?: number | undefined;
+      readonly output_tokens?: number | undefined;
+      readonly total_tokens?: number | undefined;
+      readonly input_tokens_details?: {
+        readonly cached_tokens?: number | undefined;
+        readonly cache_write_tokens?: number | undefined;
+      } | undefined;
+      readonly output_tokens_details?: {
+        readonly reasoning_tokens?: number | undefined;
+      } | undefined;
+    };
+  } | {
+    readonly type: "input-accepted";
+    readonly input: Schema.Json;
+  } | {
+    readonly type: "run-completed";
+    readonly metadata?: Schema.Json | undefined;
+  } | {
+    readonly type: "run-interrupted";
+    readonly interrupts: readonly {
+      readonly callId: string;
+      readonly reason: "approval";
+      readonly name: string;
+      readonly input: Schema.Json;
+    }[];
+  } | {
+    readonly type: "object-done";
+    readonly id: string;
+    readonly name?: string | undefined;
+    readonly value: Schema.Json;
+  } | {
+    readonly type: "tool-call-ready";
+    readonly callId: string;
+    readonly name: string;
+    readonly input: Schema.Json;
+  } | {
+    readonly type: "tool-approval-requested";
+    readonly callId: string;
+    readonly name: string;
+    readonly input: Schema.Json;
+  } | {
+    readonly type: "tool-partial";
+    readonly callId: string;
+    readonly name: string;
+    readonly value: Schema.Json;
+  } | {
+    readonly type: "tool-result";
+    readonly callId: string;
+    readonly name: string;
+    readonly result: {
+      readonly _tag: "Success";
+      readonly value: Schema.Json;
+    } | {
+      readonly _tag: "Failure";
+      readonly error: Schema.Json;
+    };
+  } | {
+    readonly type: "data";
+    readonly name: string;
+    readonly value: Schema.Json;
+    readonly id?: string | undefined;
+  } | {
+    readonly type: "live";
+    readonly name: string;
+    readonly value: Schema.Json;
+  };
+}, HttpClientError.HttpClientError | Ndjson.NdjsonError | Schema.SchemaError, HttpClient.HttpClient>;
+/**
+ * Keep events flowing across dropped connections: `connect(after)` is
+ * re-invoked with the last seen `seq` on failure, per `schedule`; duplicates
+ * are dropped. A connection that ends cleanly before the end counts as a
+ * failure (`Disconnected`), so it is retried too.
+ *
+ * `until: "terminal"` (default) follows one run and completes after its
+ * terminal. `until: "never"` follows a session stream that carries many runs
+ * (a durable chat) and never completes on its own.
+ */
+declare const resumable: <E, R, X>(connect: (after: number) => Stream.Stream<Envelope, E, R>, options: {
+  readonly from?: number;
+  readonly until?: "terminal" | "never";
+  readonly schedule: Schedule.Schedule<X, E | Disconnected>;
+}) => Stream.Stream<Envelope, E | Disconnected, R>;
+//#endregion
+export { ndjson as a, execute as i, Client_d_exports as n, resumable as o, Disconnected as r, sse as s, ClientError as t };
+//# sourceMappingURL=Client-C9UYN_VK.d.mts.map

package/dist/Client-C9UYN_VK.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Client-C9UYN_VK.d.mts","names":[],"sources":["../src/Client.ts"],"mappings":";;;;;;;;;;;cAaa,qBAAqB;WAA4C;;;KAGlE,cACR,gBAAgB,kBAChB,OAAO,cACP,IAAI,QACJ,IAAI,WACJ,OAAO;;cAGE,UAAO,SAAa,kBAAkB,sBAAiB,OAAA,gDAAA,oBAAA,gBAAA,iBAAA,WAAA;;cASvD,MAAG,SAAa,kBAAkB,sBAAiB,OAAA,OAAA,UAAA,gBAAA,kBAAA,IAAA,QAAA,OAAA,cAAA,IAAA,UAAA,WAAA;;cAInD,SAAM,SAAa,kBAAkB,sBAAiB,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GACuB,gBAAA,kBAAA,OAAA,cAAA,OAAA,aAAA,WAAA;;;;;;;;;;;cAY7E,YAAa,GAAG,GAAG,GAAC,UACrB,kBAAkB,OAAO,OAAO,UAAU,GAAG,IAAE;WAE9C;WACA;WACA,UAAU,SAAS,SAAS,GAAG,IAAI;MAE7C,OAAO,OAAO,UAAU,IAAI,cAAc"}

package/dist/Client.d.mts

@@ -0,0 +1,2 @@
+import { a as ndjson, i as execute, o as resumable, r as Disconnected, s as sse, t as ClientError } from "./Client-C9UYN_VK.mjs";
+export { ClientError, Disconnected, execute, ndjson, resumable, sse };