@effect-uai/ui 0.0.0-stage → 0.17.0

package/dist/Client.mjs

@@ -0,0 +1,55 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { EnvelopeJson, isTerminal } from "./RunEvent.mjs";
+import { decode } from "./SseEncoding.mjs";
+import { Data, Effect, Ref, Stream } from "effect";
+import { Ndjson } from "effect/encoding";
+import { HttpClient } from "effect/http";
+//#region src/Client.ts
+/**
+* Browser-safe sources of envelopes. Every source yields
+* `Stream<Envelope>`; `resumable` adds reconnect-from-last-seq on top of
+* any of them. HTTP goes through `effect/http`'s `HttpClient`, so a browser
+* provides `FetchHttpClient.layer` and tests provide a fake client.
+*/
+var Client_exports = /* @__PURE__ */ __exportAll({
+	Disconnected: () => Disconnected,
+	execute: () => execute,
+	ndjson: () => ndjson,
+	resumable: () => resumable,
+	sse: () => sse
+});
+/** The connection ended before the run's terminal event arrived. */
+var Disconnected = class extends Data.TaggedError("Disconnected") {};
+/** Run a request, failing on a non-2xx status. */
+const execute = (request) => HttpClient.HttpClient.pipe(Effect.flatMap((client) => HttpClient.filterStatusOk(client).execute(request)));
+const body = (request) => Stream.unwrap(Effect.map(execute(request), (response) => response.stream));
+/** An SSE response (`text/event-stream`) as envelopes. */
+const sse = (request) => body(request).pipe(decode);
+/** An NDJSON response (one envelope per line) as envelopes. */
+const ndjson = (request) => body(request).pipe(Stream.pipeThroughChannelOrFail(Ndjson.decodeSchema(EnvelopeJson)()));
+/**
+* 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.
+*/
+const resumable = (connect, options) => Stream.unwrap(Effect.gen(function* () {
+	const untilTerminal = options.until !== "never";
+	const ends = (envelope) => untilTerminal && isTerminal(envelope.event);
+	const position = yield* Ref.make({
+		seq: options.from ?? 0,
+		done: false
+	});
+	return Stream.unwrap(Ref.get(position).pipe(Effect.map(({ seq: after }) => connect(after).pipe(Stream.filterEffect((envelope) => Ref.modify(position, (p) => envelope.seq > p.seq ? [true, {
+		seq: envelope.seq,
+		done: ends(envelope)
+	}] : [false, p])), Stream.takeUntil(ends), Stream.concat(Stream.unwrap(Ref.get(position).pipe(Effect.map((p) => p.done ? Stream.empty : Stream.fail(new Disconnected({ lastSeq: p.seq })))))))))).pipe(Stream.retry(options.schedule));
+}));
+//#endregion
+export { Disconnected, execute, ndjson, resumable, sse, Client_exports as t };
+
+//# sourceMappingURL=Client.mjs.map

package/dist/Client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Client.mjs","names":["SseEncoding.decode"],"sources":["../src/Client.ts"],"sourcesContent":["/**\n * Browser-safe sources of envelopes. Every source yields\n * `Stream<Envelope>`; `resumable` adds reconnect-from-last-seq on top of\n * any of them. HTTP goes through `effect/http`'s `HttpClient`, so a browser\n * provides `FetchHttpClient.layer` and tests provide a fake client.\n */\nimport { Data, Effect, Ref, type Schedule, type Schema, Stream } from \"effect\"\nimport { Ndjson, type Sse } from \"effect/encoding\"\nimport { HttpClient, type HttpClientError, type HttpClientRequest } from \"effect/http\"\nimport { type Envelope, EnvelopeJson, isTerminal } from \"./RunEvent.js\"\nimport * as SseEncoding from \"./SseEncoding.js\"\n\n/** The connection ended before the run's terminal event arrived. */\nexport class Disconnected extends Data.TaggedError(\"Disconnected\")<{ readonly lastSeq: number }> {}\n\n/** What an HTTP source can fail with: transport, a malformed SSE frame, or a malformed NDJSON line. */\nexport type ClientError =\n  | HttpClientError.HttpClientError\n  | Schema.SchemaError\n  | Sse.Retry\n  | Sse.SseError\n  | Ndjson.NdjsonError\n\n/** Run a request, failing on a non-2xx status. */\nexport const execute = (request: HttpClientRequest.HttpClientRequest) =>\n  HttpClient.HttpClient.pipe(\n    Effect.flatMap((client) => HttpClient.filterStatusOk(client).execute(request)),\n  )\n\nconst body = (request: HttpClientRequest.HttpClientRequest) =>\n  Stream.unwrap(Effect.map(execute(request), (response) => response.stream))\n\n/** An SSE response (`text/event-stream`) as envelopes. */\nexport const sse = (request: HttpClientRequest.HttpClientRequest) =>\n  body(request).pipe(SseEncoding.decode)\n\n/** An NDJSON response (one envelope per line) as envelopes. */\nexport const ndjson = (request: HttpClientRequest.HttpClientRequest) =>\n  body(request).pipe(Stream.pipeThroughChannelOrFail(Ndjson.decodeSchema(EnvelopeJson)()))\n\n/**\n * Keep events flowing across dropped connections: `connect(after)` is\n * re-invoked with the last seen `seq` on failure, per `schedule`; duplicates\n * are dropped. A connection that ends cleanly before the end counts as a\n * failure (`Disconnected`), so it is retried too.\n *\n * `until: \"terminal\"` (default) follows one run and completes after its\n * terminal. `until: \"never\"` follows a session stream that carries many runs\n * (a durable chat) and never completes on its own.\n */\nexport const resumable = <E, R, X>(\n  connect: (after: number) => Stream.Stream<Envelope, E, R>,\n  options: {\n    readonly from?: number\n    readonly until?: \"terminal\" | \"never\"\n    readonly schedule: Schedule.Schedule<X, E | Disconnected>\n  },\n): Stream.Stream<Envelope, E | Disconnected, R> =>\n  Stream.unwrap(\n    Effect.gen(function* () {\n      const untilTerminal = options.until !== \"never\"\n      const ends = (envelope: Envelope) => untilTerminal && isTerminal(envelope.event)\n      // The last seen seq, and whether the run's terminal arrived.\n      const position = yield* Ref.make({ seq: options.from ?? 0, done: false })\n      const attempt = Stream.unwrap(\n        Ref.get(position).pipe(\n          Effect.map(({ seq: after }) =>\n            connect(after).pipe(\n              Stream.filterEffect((envelope) =>\n                Ref.modify(position, (p) =>\n                  envelope.seq > p.seq\n                    ? [true, { seq: envelope.seq, done: ends(envelope) }]\n                    : [false, p],\n                ),\n              ),\n              Stream.takeUntil(ends),\n              Stream.concat(\n                Stream.unwrap(\n                  Ref.get(position).pipe(\n                    Effect.map((p) =>\n                      p.done ? Stream.empty : Stream.fail(new Disconnected({ lastSeq: p.seq })),\n                    ),\n                  ),\n                ),\n              ),\n            ),\n          ),\n        ),\n      )\n      return attempt.pipe(Stream.retry(options.schedule))\n    }),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAaA,IAAa,eAAb,cAAkC,KAAK,YAAY,cAAc,CAAC,CAA+B,CAAC;;AAWlG,MAAa,WAAW,YACtB,WAAW,WAAW,KACpB,OAAO,SAAS,WAAW,WAAW,eAAe,MAAM,CAAC,CAAC,QAAQ,OAAO,CAAC,CAC/E;AAEF,MAAM,QAAQ,YACZ,OAAO,OAAO,OAAO,IAAI,QAAQ,OAAO,IAAI,aAAa,SAAS,MAAM,CAAC;;AAG3E,MAAa,OAAO,YAClB,KAAK,OAAO,CAAC,CAAC,KAAKA,MAAkB;;AAGvC,MAAa,UAAU,YACrB,KAAK,OAAO,CAAC,CAAC,KAAK,OAAO,yBAAyB,OAAO,aAAa,YAAY,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;AAYzF,MAAa,aACX,SACA,YAMA,OAAO,OACL,OAAO,IAAI,aAAa;CACtB,MAAM,gBAAgB,QAAQ,UAAU;CACxC,MAAM,QAAQ,aAAuB,iBAAiB,WAAW,SAAS,KAAK;CAE/E,MAAM,WAAW,OAAO,IAAI,KAAK;EAAE,KAAK,QAAQ,QAAQ;EAAG,MAAM;CAAM,CAAC;CA0BxE,OAzBgB,OAAO,OACrB,IAAI,IAAI,QAAQ,CAAC,CAAC,KAChB,OAAO,KAAK,EAAE,KAAK,YACjB,QAAQ,KAAK,CAAC,CAAC,KACb,OAAO,cAAc,aACnB,IAAI,OAAO,WAAW,MACpB,SAAS,MAAM,EAAE,MACb,CAAC,MAAM;EAAE,KAAK,SAAS;EAAK,MAAM,KAAK,QAAQ;CAAE,CAAC,IAClD,CAAC,OAAO,CAAC,CACf,CACF,GACA,OAAO,UAAU,IAAI,GACrB,OAAO,OACL,OAAO,OACL,IAAI,IAAI,QAAQ,CAAC,CAAC,KAChB,OAAO,KAAK,MACV,EAAE,OAAO,OAAO,QAAQ,OAAO,KAAK,IAAI,aAAa,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC,CAC1E,CACF,CACF,CACF,CACF,CACF,CACF,CAEW,CAAC,CAAC,KAAK,OAAO,MAAM,QAAQ,QAAQ,CAAC;AACpD,CAAC,CACH"}

package/dist/Input-Cz-Kxusm.d.mts

@@ -0,0 +1,277 @@
+import { InputId } from "./RunEvent.mjs";
+import { Effect, Schema } from "effect";
+import * as ToolDecision from "@effect-uai/core/ToolDecision";
+import { SecureRandom } from "effect/crypto";
+declare namespace Input_d_exports {
+  export { Content, Decision, Draft, Identified, Input, InputJson, Resolve, ResolveDraft, Sent, Submit, SubmitJson, UserMessage, answer, make, resolve, submit, text, user, withId };
+}
+/** A user message: core's `message` item with role `user` and input blocks only. */
+declare const UserMessage: Schema.Struct<{
+  readonly type: Schema.Literal<"message">;
+  readonly role: Schema.Literal<"user">;
+  readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"input_text">;
+    readonly text: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"input_image">;
+    readonly source: Schema.Codec<import("@effect-uai/core/Image").ImageSource, import("@effect-uai/core/Image").ImageSource, never, never>;
+  }>]>>;
+}>;
+type UserMessage = typeof UserMessage.Type;
+type Content = UserMessage["content"][number];
+/** The answer to one waiting call, with a decision of the app's `ToolDecision.make`. */
+declare const answer: <D extends Schema.Top>(decision: D) => Schema.Struct<{
+  readonly callId: Schema.String;
+  readonly decision: D;
+}>;
+/** The default answer: `ToolDecision.Default` (approve, or deny with an optional reason). */
+declare const Decision: Schema.Struct<{
+  readonly callId: Schema.String;
+  readonly decision: Schema.Codec<ToolDecision.DecisionOf<{
+    readonly Approve: {};
+    readonly Deny: ToolDecision.Closing<{
+      readonly reason: Schema.optionalKey<Schema.String>;
+    }, ToolDecision.Denied>;
+  }>, unknown, never, never>;
+}>;
+type Decision = typeof Decision.Type;
+declare const Submit: Schema.Struct<{
+  id: Schema.brand<Schema.String, "InputId">;
+  kind: Schema.Literal<"submit">;
+  messages: Schema.$Array<Schema.Struct<{
+    readonly type: Schema.Literal<"message">;
+    readonly role: Schema.Literal<"user">;
+    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"input_text">;
+      readonly text: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"input_image">;
+      readonly source: Schema.Codec<import("@effect-uai/core/Image").ImageSource, import("@effect-uai/core/Image").ImageSource, never, never>;
+    }>]>>;
+  }>>;
+}>;
+type Submit = typeof Submit.Type;
+declare const Resolve: Schema.Struct<{
+  id: Schema.brand<Schema.String, "InputId">;
+  kind: Schema.Literal<"resolve">;
+  decisions: Schema.$Array<Schema.Struct<{
+    readonly callId: Schema.String;
+    readonly decision: Schema.Codec<ToolDecision.DecisionOf<{
+      readonly Approve: {};
+      readonly Deny: ToolDecision.Closing<{
+        readonly reason: Schema.optionalKey<Schema.String>;
+      }, ToolDecision.Denied>;
+    }>, unknown, never, never>;
+  }>>;
+}>;
+type Resolve = typeof Resolve.Type;
+declare const Input: Schema.Union<readonly [Schema.Struct<{
+  id: Schema.brand<Schema.String, "InputId">;
+  kind: Schema.Literal<"submit">;
+  messages: Schema.$Array<Schema.Struct<{
+    readonly type: Schema.Literal<"message">;
+    readonly role: Schema.Literal<"user">;
+    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"input_text">;
+      readonly text: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"input_image">;
+      readonly source: Schema.Codec<import("@effect-uai/core/Image").ImageSource, import("@effect-uai/core/Image").ImageSource, never, never>;
+    }>]>>;
+  }>>;
+}>, Schema.Struct<{
+  id: Schema.brand<Schema.String, "InputId">;
+  kind: Schema.Literal<"resolve">;
+  decisions: Schema.$Array<Schema.Struct<{
+    readonly callId: Schema.String;
+    readonly decision: Schema.Codec<ToolDecision.DecisionOf<{
+      readonly Approve: {};
+      readonly Deny: ToolDecision.Closing<{
+        readonly reason: Schema.optionalKey<Schema.String>;
+      }, ToolDecision.Denied>;
+    }>, unknown, never, never>;
+  }>>;
+}>]>;
+type Input = typeof Input.Type;
+declare const SubmitJson: Schema.toCodecJson<Schema.Struct<{
+  id: Schema.brand<Schema.String, "InputId">;
+  kind: Schema.Literal<"submit">;
+  messages: Schema.$Array<Schema.Struct<{
+    readonly type: Schema.Literal<"message">;
+    readonly role: Schema.Literal<"user">;
+    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"input_text">;
+      readonly text: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"input_image">;
+      readonly source: Schema.Codec<import("@effect-uai/core/Image").ImageSource, import("@effect-uai/core/Image").ImageSource, never, never>;
+    }>]>>;
+  }>>;
+}>>;
+declare const InputJson: Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+  id: Schema.brand<Schema.String, "InputId">;
+  kind: Schema.Literal<"submit">;
+  messages: Schema.$Array<Schema.Struct<{
+    readonly type: Schema.Literal<"message">;
+    readonly role: Schema.Literal<"user">;
+    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"input_text">;
+      readonly text: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"input_image">;
+      readonly source: Schema.Codec<import("@effect-uai/core/Image").ImageSource, import("@effect-uai/core/Image").ImageSource, never, never>;
+    }>]>>;
+  }>>;
+}>, Schema.Struct<{
+  id: Schema.brand<Schema.String, "InputId">;
+  kind: Schema.Literal<"resolve">;
+  decisions: Schema.$Array<Schema.Struct<{
+    readonly callId: Schema.String;
+    readonly decision: Schema.Codec<ToolDecision.DecisionOf<{
+      readonly Approve: {};
+      readonly Deny: ToolDecision.Closing<{
+        readonly reason: Schema.optionalKey<Schema.String>;
+      }, ToolDecision.Denied>;
+    }>, unknown, never, never>;
+  }>>;
+}>]>>;
+/**
+ * The preset with typed app `data` (required on `submit`, optional on
+ * `resolve`) and, optionally, the app's decisions (`ToolDecision.make(...).schema`).
+ */
+declare function make<D extends Schema.Top>(data: D): Preset<D, typeof ToolDecision.Default.schema>;
+declare function make<D extends Schema.Top, A extends Schema.Top>(data: D, decisions: A): Preset<D, A>;
+type Preset<D extends Schema.Top, A extends Schema.Top> = ReturnType<typeof preset<D, A>>;
+declare const preset: <D extends Schema.Top, A extends Schema.Top>(data: D, decisions: A) => {
+  Submit: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InputId">;
+    readonly kind: Schema.Literal<"submit">;
+    readonly messages: Schema.$Array<Schema.Struct<{
+      readonly type: Schema.Literal<"message">;
+      readonly role: Schema.Literal<"user">;
+      readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"input_text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"input_image">;
+        readonly source: Schema.Codec<import("@effect-uai/core/Image").ImageSource, import("@effect-uai/core/Image").ImageSource, never, never>;
+      }>]>>;
+    }>>;
+    readonly data: D;
+  }>;
+  Resolve: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InputId">;
+    readonly kind: Schema.Literal<"resolve">;
+    readonly decisions: Schema.$Array<Schema.Struct<{
+      readonly callId: Schema.String;
+      readonly decision: A;
+    }>>;
+    readonly data: Schema.optionalKey<D>;
+  }>;
+  Input: Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InputId">;
+    readonly kind: Schema.Literal<"submit">;
+    readonly messages: Schema.$Array<Schema.Struct<{
+      readonly type: Schema.Literal<"message">;
+      readonly role: Schema.Literal<"user">;
+      readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"input_text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"input_image">;
+        readonly source: Schema.Codec<import("@effect-uai/core/Image").ImageSource, import("@effect-uai/core/Image").ImageSource, never, never>;
+      }>]>>;
+    }>>;
+    readonly data: D;
+  }>, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InputId">;
+    readonly kind: Schema.Literal<"resolve">;
+    readonly decisions: Schema.$Array<Schema.Struct<{
+      readonly callId: Schema.String;
+      readonly decision: A;
+    }>>;
+    readonly data: Schema.optionalKey<D>;
+  }>]>;
+  SubmitJson: Schema.toCodecJson<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InputId">;
+    readonly kind: Schema.Literal<"submit">;
+    readonly messages: Schema.$Array<Schema.Struct<{
+      readonly type: Schema.Literal<"message">;
+      readonly role: Schema.Literal<"user">;
+      readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"input_text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"input_image">;
+        readonly source: Schema.Codec<import("@effect-uai/core/Image").ImageSource, import("@effect-uai/core/Image").ImageSource, never, never>;
+      }>]>>;
+    }>>;
+    readonly data: D;
+  }>>;
+  InputJson: Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InputId">;
+    readonly kind: Schema.Literal<"submit">;
+    readonly messages: Schema.$Array<Schema.Struct<{
+      readonly type: Schema.Literal<"message">;
+      readonly role: Schema.Literal<"user">;
+      readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"input_text">;
+        readonly text: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"input_image">;
+        readonly source: Schema.Codec<import("@effect-uai/core/Image").ImageSource, import("@effect-uai/core/Image").ImageSource, never, never>;
+      }>]>>;
+    }>>;
+    readonly data: D;
+  }>, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "InputId">;
+    readonly kind: Schema.Literal<"resolve">;
+    readonly decisions: Schema.$Array<Schema.Struct<{
+      readonly callId: Schema.String;
+      readonly decision: A;
+    }>>;
+    readonly data: Schema.optionalKey<D>;
+  }>]>>;
+};
+/** An input whose `id` is not assigned yet (per union member). */
+type Draft<I> = I extends unknown ? Omit<I, "id"> & {
+  readonly id?: InputId;
+} : never;
+/** A draft with its `id` assigned. */
+type Identified<D> = D & {
+  readonly id: InputId;
+};
+/** What a transport receives for inputs of type `I`: the draft `submit` took, with its id. */
+type Sent<I = Input> = Identified<Draft<I>>;
+/** Assign a UUIDv7 id unless the draft already has one. */
+declare const withId: <D extends {
+  readonly id?: InputId;
+}>(draft: D) => Effect.Effect<Identified<D>, never, SecureRandom.SecureRandom>;
+/** A user message: `text` first, then any attachments (images). */
+declare const user: (text: string, attachments?: ReadonlyArray<Content>) => UserMessage;
+type Id = {
+  readonly id?: InputId;
+};
+declare function submit(messages: string | ReadonlyArray<UserMessage>, options?: Id): Draft<Submit>;
+declare function submit<D>(messages: string | ReadonlyArray<UserMessage>, options: Id & {
+  readonly data: D;
+}): Draft<Submit> & {
+  readonly data: D;
+};
+/** A resolve draft; the decision type defaults to `ToolDecision.Default`'s. */
+type ResolveDraft<A = Decision["decision"]> = {
+  readonly id?: InputId;
+  readonly kind: "resolve";
+  readonly decisions: ReadonlyArray<ToolDecision.Answer<A>>;
+};
+declare function resolve<A = Decision["decision"]>(decisions: ReadonlyArray<ToolDecision.Answer<A>>, options?: Id): ResolveDraft<A>;
+declare function resolve<A, D>(decisions: ReadonlyArray<ToolDecision.Answer<A>>, options: Id & {
+  readonly data: D;
+}): ResolveDraft<A> & {
+  readonly data: D;
+};
+/** All text of the submit's messages, joined by blank lines. */
+declare const text: (input: Pick<Submit, "messages">) => string;
+//#endregion
+export { submit as _, Input as a, withId as b, Resolve as c, Submit as d, SubmitJson as f, resolve as g, make as h, Identified as i, ResolveDraft as l, answer as m, Decision as n, InputJson as o, UserMessage as p, Draft as r, Input_d_exports as s, Content as t, Sent as u, text as v, user as y };
+//# sourceMappingURL=Input-Cz-Kxusm.d.mts.map

package/dist/Input-Cz-Kxusm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Input-Cz-Kxusm.d.mts","names":[],"sources":["../src/Input.ts"],"mappings":";;;;;;;;cAqBa,aAAW,OAAA;;;;;;;;;;;KAKZ,qBAAqB,YAAY;KACjC,UAAU;;cAGT,SAAU,UAAU,OAAO,KAAG,UAAY,MAAC,OAAA;;;;;cAI3C,UAAQ,OAAA;;;;;;;;;KACT,kBAAkB,SAAS;cAc1B,QAAM,OAAA;;;;;;;;;;;;;;;KACP,gBAAgB,OAAO;cAEtB,SAAO,OAAA;;;;;;;;;;;;;KACR,iBAAiB,QAAQ;cAExB,OAAK,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KACN,eAAe,MAAM;cAEpB,YAAU,OAAA,YAAA,OAAA;;;;;;;;;;;;;;;cACV,WAAS,OAAA,YAAA,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMN,KAAK,UAAU,OAAO,KAAK,MAAM,IAAI,OAAO,UAAU,aAAa,QAAQ;iBAC3E,KAAK,UAAU,OAAO,KAAK,UAAU,OAAO,KAC1D,MAAM,GACN,WAAW,IACV,OAAO,GAAG;KAKR,OAAO,UAAU,OAAO,KAAK,UAAU,OAAO,OAAO,kBAAkB,OAAO,GAAG;cAEhF,SAAU,UAAU,OAAO,KAAK,UAAU,OAAO,KAAG,MAAQ,GAAC,WAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAcpE,MAAM,KAAK,oBAAoB,KAAK;WAAsB,KAAK;;;KAG/D,WAAW,KAAK;WAAe,IAAI;;;KAGnC,KAAK,IAAI,SAAS,WAAW,MAAM;;cAGlC,SAAU;WAAqB,KAAK;GAAS,OACjD,MACN,OAAO,OAAO,WAAW,WAAW,aAAa;;cAUvC,OAAI,cAAgB,cAAe,cAAc,aAAgB;KAMzE;WAAgB,KAAK;;iBAKV,OAAO,mBAAmB,cAAc,cAAc,UAAU,KAAK,MAAM;iBAC3E,OAAO,GACrB,mBAAmB,cAAc,cACjC,SAAS;WAAgB,MAAM;IAC9B,MAAM;WAAqB,MAAM;;;KAaxB,aAAa,IAAI;WAClB,KAAK;WACL;WACA,WAAW,cAAc,aAAa,OAAO;;iBAGxC,QAAQ,IAAI,sBAC1B,WAAW,cAAc,aAAa,OAAO,KAC7C,UAAU,KACT,aAAa;iBACA,QAAQ,GAAG,GACzB,WAAW,cAAc,aAAa,OAAO,KAC7C,SAAS;WAAgB,MAAM;IAC9B,aAAa;WAAgB,MAAM;;;cASzB,OAAI,OAAW,KAAK"}

package/dist/Input.d.mts

@@ -0,0 +1,2 @@
+import { _ as submit, a as Input, b as withId, c as Resolve, d as Submit, f as SubmitJson, g as resolve, h as make, i as Identified, l as ResolveDraft, m as answer, n as Decision, o as InputJson, p as UserMessage, r as Draft, t as Content, u as Sent, v as text, y as user } from "./Input-Cz-Kxusm.mjs";
+export { Content, Decision, Draft, Identified, Input, InputJson, Resolve, ResolveDraft, Sent, Submit, SubmitJson, UserMessage, answer, make, resolve, submit, text, user, withId };

package/dist/Input.mjs

@@ -0,0 +1,127 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { InputId } from "./RunEvent.mjs";
+import { Effect, Schema } from "effect";
+import * as ToolDecision from "@effect-uai/core/ToolDecision";
+import * as Items from "@effect-uai/core/Items";
+import { SecureRandom } from "effect/crypto";
+//#region src/Input.ts
+/**
+* What a client sends to start or continue a run. The library only needs an
+* `id` on an input (generated on the client, so optimistic UI can match it
+* to `run-started { inputs }`); this module is a preset, and an app with a
+* different shape passes its own schema.
+*
+* A `submit` carries user `messages` (core message items: the server appends
+* them to its history as they are) and, with `make(DataSchema)`, typed `data` the server
+* interprets (template id, model choice). Decode request bodies with the
+* `*Json` codecs: they carry image bytes over JSON.
+*
+* Constructors build drafts without randomness; the id is assigned where an
+* input is sent (`Atoms.submit`, or `withId`).
+*/
+var Input_exports = /* @__PURE__ */ __exportAll({
+	Decision: () => Decision,
+	Input: () => Input,
+	InputJson: () => InputJson,
+	Resolve: () => Resolve,
+	Submit: () => Submit,
+	SubmitJson: () => SubmitJson,
+	UserMessage: () => UserMessage,
+	answer: () => answer,
+	make: () => make,
+	resolve: () => resolve,
+	submit: () => submit,
+	text: () => text,
+	user: () => user,
+	withId: () => withId
+});
+/** A user message: core's `message` item with role `user` and input blocks only. */
+const UserMessage = Schema.Struct({
+	type: Schema.Literal("message"),
+	role: Schema.Literal("user"),
+	content: Schema.Array(Schema.Union([Items.InputText, Items.InputImage]))
+});
+/** The answer to one waiting call, with a decision of the app's `ToolDecision.make`. */
+const answer = (decision) => Schema.Struct({
+	callId: Schema.String,
+	decision
+});
+/** The default answer: `ToolDecision.Default` (approve, or deny with an optional reason). */
+const Decision = answer(ToolDecision.Default.schema);
+const submitFields = {
+	id: InputId,
+	kind: Schema.Literal("submit"),
+	messages: Schema.Array(UserMessage)
+};
+const resolveFields = (decision) => ({
+	id: InputId,
+	kind: Schema.Literal("resolve"),
+	decisions: Schema.Array(answer(decision))
+});
+const Submit = Schema.Struct(submitFields);
+const Resolve = Schema.Struct(resolveFields(ToolDecision.Default.schema));
+const Input = Schema.Union([Submit, Resolve]);
+const SubmitJson = Schema.toCodecJson(Submit);
+const InputJson = Schema.toCodecJson(Input);
+function make(data, decisions = ToolDecision.Default.schema) {
+	return preset(data, decisions);
+}
+const preset = (data, decisions) => {
+	const Submit = Schema.Struct({
+		...submitFields,
+		data
+	});
+	const Resolve = Schema.Struct({
+		...resolveFields(decisions),
+		data: Schema.optionalKey(data)
+	});
+	const Input = Schema.Union([Submit, Resolve]);
+	return {
+		Submit,
+		Resolve,
+		Input,
+		SubmitJson: Schema.toCodecJson(Submit),
+		InputJson: Schema.toCodecJson(Input)
+	};
+};
+/** Assign a UUIDv7 id unless the draft already has one. */
+const withId = (draft) => {
+	const { id } = draft;
+	return id !== void 0 ? Effect.succeed({
+		...draft,
+		id
+	}) : SecureRandom.SecureRandom.use((random) => random.uuidV7()).pipe(Effect.map((uuid) => ({
+		...draft,
+		id: InputId.make(uuid)
+	})));
+};
+/** A user message: `text` first, then any attachments (images). */
+const user = (text, attachments = []) => ({
+	type: "message",
+	role: "user",
+	content: [{
+		type: "input_text",
+		text
+	}, ...attachments]
+});
+const toMessages = (messages) => typeof messages === "string" ? [user(messages)] : messages;
+function submit(messages, options) {
+	return {
+		...options,
+		kind: "submit",
+		messages: toMessages(messages)
+	};
+}
+function resolve(decisions, options) {
+	return {
+		...options,
+		kind: "resolve",
+		decisions
+	};
+}
+/** All text of the submit's messages, joined by blank lines. */
+const text = (input) => input.messages.flatMap((m) => m.content.flatMap((block) => block.type === "input_text" ? [block.text] : [])).join("\n\n");
+//#endregion
+export { Decision, Input, InputJson, Resolve, Submit, SubmitJson, UserMessage, answer, make, resolve, submit, Input_exports as t, text, user, withId };
+
+//# sourceMappingURL=Input.mjs.map

package/dist/Input.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Input.mjs","names":[],"sources":["../src/Input.ts"],"sourcesContent":["/**\n * What a client sends to start or continue a run. The library only needs an\n * `id` on an input (generated on the client, so optimistic UI can match it\n * to `run-started { inputs }`); this module is a preset, and an app with a\n * different shape passes its own schema.\n *\n * A `submit` carries user `messages` (core message items: the server appends\n * them to its history as they are) and, with `make(DataSchema)`, typed `data` the server\n * interprets (template id, model choice). Decode request bodies with the\n * `*Json` codecs: they carry image bytes over JSON.\n *\n * Constructors build drafts without randomness; the id is assigned where an\n * input is sent (`Atoms.submit`, or `withId`).\n */\nimport * as ToolDecision from \"@effect-uai/core/ToolDecision\"\nimport * as Items from \"@effect-uai/core/Items\"\nimport { Effect, Schema } from \"effect\"\nimport { SecureRandom } from \"effect/crypto\"\nimport { InputId } from \"./RunEvent.js\"\n\n/** A user message: core's `message` item with role `user` and input blocks only. */\nexport const UserMessage = Schema.Struct({\n  type: Schema.Literal(\"message\"),\n  role: Schema.Literal(\"user\"),\n  content: Schema.Array(Schema.Union([Items.InputText, Items.InputImage])),\n})\nexport type UserMessage = typeof UserMessage.Type\nexport type Content = UserMessage[\"content\"][number]\n\n/** The answer to one waiting call, with a decision of the app's `ToolDecision.make`. */\nexport const answer = <D extends Schema.Top>(decision: D) =>\n  Schema.Struct({ callId: Schema.String, decision })\n\n/** The default answer: `ToolDecision.Default` (approve, or deny with an optional reason). */\nexport const Decision = answer(ToolDecision.Default.schema)\nexport type Decision = typeof Decision.Type\n\nconst submitFields = {\n  id: InputId,\n  kind: Schema.Literal(\"submit\"),\n  messages: Schema.Array(UserMessage),\n}\n\nconst resolveFields = <D extends Schema.Top>(decision: D) => ({\n  id: InputId,\n  kind: Schema.Literal(\"resolve\"),\n  decisions: Schema.Array(answer(decision)),\n})\n\nexport const Submit = Schema.Struct(submitFields)\nexport type Submit = typeof Submit.Type\n\nexport const Resolve = Schema.Struct(resolveFields(ToolDecision.Default.schema))\nexport type Resolve = typeof Resolve.Type\n\nexport const Input = Schema.Union([Submit, Resolve])\nexport type Input = typeof Input.Type\n\nexport const SubmitJson = Schema.toCodecJson(Submit)\nexport const InputJson = Schema.toCodecJson(Input)\n\n/**\n * The preset with typed app `data` (required on `submit`, optional on\n * `resolve`) and, optionally, the app's decisions (`ToolDecision.make(...).schema`).\n */\nexport function make<D extends Schema.Top>(data: D): Preset<D, typeof ToolDecision.Default.schema>\nexport function make<D extends Schema.Top, A extends Schema.Top>(\n  data: D,\n  decisions: A,\n): Preset<D, A>\nexport function make(data: Schema.Top, decisions: Schema.Top = ToolDecision.Default.schema) {\n  return preset(data, decisions)\n}\n\ntype Preset<D extends Schema.Top, A extends Schema.Top> = ReturnType<typeof preset<D, A>>\n\nconst preset = <D extends Schema.Top, A extends Schema.Top>(data: D, decisions: A) => {\n  const Submit = Schema.Struct({ ...submitFields, data })\n  const Resolve = Schema.Struct({ ...resolveFields(decisions), data: Schema.optionalKey(data) })\n  const Input = Schema.Union([Submit, Resolve])\n  return {\n    Submit,\n    Resolve,\n    Input,\n    SubmitJson: Schema.toCodecJson(Submit),\n    InputJson: Schema.toCodecJson(Input),\n  }\n}\n\n/** An input whose `id` is not assigned yet (per union member). */\nexport type Draft<I> = I extends unknown ? Omit<I, \"id\"> & { readonly id?: InputId } : never\n\n/** A draft with its `id` assigned. */\nexport type Identified<D> = D & { readonly id: InputId }\n\n/** What a transport receives for inputs of type `I`: the draft `submit` took, with its id. */\nexport type Sent<I = Input> = Identified<Draft<I>>\n\n/** Assign a UUIDv7 id unless the draft already has one. */\nexport const withId = <D extends { readonly id?: InputId }>(\n  draft: D,\n): Effect.Effect<Identified<D>, never, SecureRandom.SecureRandom> => {\n  const { id } = draft\n  return id !== undefined\n    ? Effect.succeed({ ...draft, id })\n    : SecureRandom.SecureRandom.use((random) => random.uuidV7()).pipe(\n        Effect.map((uuid) => ({ ...draft, id: InputId.make(uuid) })),\n      )\n}\n\n/** A user message: `text` first, then any attachments (images). */\nexport const user = (text: string, attachments: ReadonlyArray<Content> = []): UserMessage => ({\n  type: \"message\",\n  role: \"user\",\n  content: [{ type: \"input_text\", text }, ...attachments],\n})\n\ntype Id = { readonly id?: InputId }\n\nconst toMessages = (messages: string | ReadonlyArray<UserMessage>): ReadonlyArray<UserMessage> =>\n  typeof messages === \"string\" ? [user(messages)] : messages\n\nexport function submit(messages: string | ReadonlyArray<UserMessage>, options?: Id): Draft<Submit>\nexport function submit<D>(\n  messages: string | ReadonlyArray<UserMessage>,\n  options: Id & { readonly data: D },\n): Draft<Submit> & { readonly data: D }\nexport function submit(\n  messages: string | ReadonlyArray<UserMessage>,\n  options?: Id & { readonly data?: unknown },\n): Draft<Submit> & { readonly data?: unknown } {\n  return {\n    ...options,\n    kind: \"submit\",\n    messages: toMessages(messages),\n  }\n}\n\n/** A resolve draft; the decision type defaults to `ToolDecision.Default`'s. */\nexport type ResolveDraft<A = Decision[\"decision\"]> = {\n  readonly id?: InputId\n  readonly kind: \"resolve\"\n  readonly decisions: ReadonlyArray<ToolDecision.Answer<A>>\n}\n\nexport function resolve<A = Decision[\"decision\"]>(\n  decisions: ReadonlyArray<ToolDecision.Answer<A>>,\n  options?: Id,\n): ResolveDraft<A>\nexport function resolve<A, D>(\n  decisions: ReadonlyArray<ToolDecision.Answer<A>>,\n  options: Id & { readonly data: D },\n): ResolveDraft<A> & { readonly data: D }\nexport function resolve(\n  decisions: ReadonlyArray<ToolDecision.Answer<unknown>>,\n  options?: Id & { readonly data?: unknown },\n): ResolveDraft<unknown> & { readonly data?: unknown } {\n  return { ...options, kind: \"resolve\", decisions }\n}\n\n/** All text of the submit's messages, joined by blank lines. */\nexport const text = (input: Pick<Submit, \"messages\">): string =>\n  input.messages\n    .flatMap((m) => m.content.flatMap((block) => (block.type === \"input_text\" ? [block.text] : [])))\n    .join(\"\\n\\n\")\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,cAAc,OAAO,OAAO;CACvC,MAAM,OAAO,QAAQ,SAAS;CAC9B,MAAM,OAAO,QAAQ,MAAM;CAC3B,SAAS,OAAO,MAAM,OAAO,MAAM,CAAC,MAAM,WAAW,MAAM,UAAU,CAAC,CAAC;AACzE,CAAC;;AAKD,MAAa,UAAgC,aAC3C,OAAO,OAAO;CAAE,QAAQ,OAAO;CAAQ;AAAS,CAAC;;AAGnD,MAAa,WAAW,OAAO,aAAa,QAAQ,MAAM;AAG1D,MAAM,eAAe;CACnB,IAAI;CACJ,MAAM,OAAO,QAAQ,QAAQ;CAC7B,UAAU,OAAO,MAAM,WAAW;AACpC;AAEA,MAAM,iBAAuC,cAAiB;CAC5D,IAAI;CACJ,MAAM,OAAO,QAAQ,SAAS;CAC9B,WAAW,OAAO,MAAM,OAAO,QAAQ,CAAC;AAC1C;AAEA,MAAa,SAAS,OAAO,OAAO,YAAY;AAGhD,MAAa,UAAU,OAAO,OAAO,cAAc,aAAa,QAAQ,MAAM,CAAC;AAG/E,MAAa,QAAQ,OAAO,MAAM,CAAC,QAAQ,OAAO,CAAC;AAGnD,MAAa,aAAa,OAAO,YAAY,MAAM;AACnD,MAAa,YAAY,OAAO,YAAY,KAAK;AAWjD,SAAgB,KAAK,MAAkB,YAAwB,aAAa,QAAQ,QAAQ;CAC1F,OAAO,OAAO,MAAM,SAAS;AAC/B;AAIA,MAAM,UAAsD,MAAS,cAAiB;CACpF,MAAM,SAAS,OAAO,OAAO;EAAE,GAAG;EAAc;CAAK,CAAC;CACtD,MAAM,UAAU,OAAO,OAAO;EAAE,GAAG,cAAc,SAAS;EAAG,MAAM,OAAO,YAAY,IAAI;CAAE,CAAC;CAC7F,MAAM,QAAQ,OAAO,MAAM,CAAC,QAAQ,OAAO,CAAC;CAC5C,OAAO;EACL;EACA;EACA;EACA,YAAY,OAAO,YAAY,MAAM;EACrC,WAAW,OAAO,YAAY,KAAK;CACrC;AACF;;AAYA,MAAa,UACX,UACmE;CACnE,MAAM,EAAE,OAAO;CACf,OAAO,OAAO,KAAA,IACV,OAAO,QAAQ;EAAE,GAAG;EAAO;CAAG,CAAC,IAC/B,aAAa,aAAa,KAAK,WAAW,OAAO,OAAO,CAAC,CAAC,CAAC,KACzD,OAAO,KAAK,UAAU;EAAE,GAAG;EAAO,IAAI,QAAQ,KAAK,IAAI;CAAE,EAAE,CAC7D;AACN;;AAGA,MAAa,QAAQ,MAAc,cAAsC,CAAC,OAAoB;CAC5F,MAAM;CACN,MAAM;CACN,SAAS,CAAC;EAAE,MAAM;EAAc;CAAK,GAAG,GAAG,WAAW;AACxD;AAIA,MAAM,cAAc,aAClB,OAAO,aAAa,WAAW,CAAC,KAAK,QAAQ,CAAC,IAAI;AAOpD,SAAgB,OACd,UACA,SAC6C;CAC7C,OAAO;EACL,GAAG;EACH,MAAM;EACN,UAAU,WAAW,QAAQ;CAC/B;AACF;AAiBA,SAAgB,QACd,WACA,SACqD;CACrD,OAAO;EAAE,GAAG;EAAS,MAAM;EAAW;CAAU;AAClD;;AAGA,MAAa,QAAQ,UACnB,MAAM,SACH,SAAS,MAAM,EAAE,QAAQ,SAAS,UAAW,MAAM,SAAS,eAAe,CAAC,MAAM,IAAI,IAAI,CAAC,CAAE,CAAC,CAAC,CAC/F,KAAK,MAAM"}

package/dist/Projection.d.mts

@@ -0,0 +1,44 @@
+import { RunEvent } from "./RunEvent.mjs";
+import { UiContract } from "./UiContract.mjs";
+import { Effect, Schema, Stream } from "effect";
+import * as Items from "@effect-uai/core/Items";
+import * as Turn from "@effect-uai/core/Turn";
+import * as ToolEvent from "@effect-uai/core/ToolEvent";
+declare namespace Projection_d_exports {
+  export { Config, Options, Source, State, initial, step, toRunEvents };
+}
+/** What an effect-uai loop emits: turn events, tool events, and plain tool outputs. */
+type Source = Turn.TurnEvent | ToolEvent.ToolEvent | Items.ToolCallOutput;
+declare const Options: Schema.Struct<{
+  /**
+   * `"signal"` (default): only `reasoning-started`. `"summary"`: also
+   * forward summary deltas. `"full"`: also forward raw reasoning traces.
+   */
+  readonly reasoning: Schema.optionalKey<Schema.Literals<readonly ["signal", "summary", "full"]>>;
+  /** Forward raw tool-argument deltas (`tool-call-args-delta`). Default false. */
+  readonly toolArgs: Schema.optionalKey<Schema.Boolean>;
+}>;
+type Options = typeof Options.Type;
+/** `Options` plus the contract whose tool schemas encode tool values and errors. */
+type Config = Options & {
+  readonly contract: Pick<UiContract<any>, "toolEvent" | "toolOutput">;
+};
+declare const State: Schema.Struct<{
+  readonly inStep: Schema.Boolean;
+  readonly reasoningShown: Schema.Boolean;
+  /** Tool names by call id, for outputs that arrive as plain `function_call_output` items. */
+  readonly tools: Schema.$Record<Schema.String, Schema.String>;
+}>;
+type State = typeof State.Type;
+declare const initial: State;
+type Step = readonly [State, ReadonlyArray<RunEvent>];
+/** Map one loop event onto zero or more `RunEvent`s; tool values are encoded by the contract. */
+declare const step: (config: Config) => (s: State, event: Source) => Effect.Effect<Step, Schema.SchemaError>;
+/**
+ * Stream operator: project a loop's events onto `RunEvent`s. A tool value the
+ * contract can't encode fails the stream: a contract violation, not data to show.
+ */
+declare const toRunEvents: (config: Config) => <E, R>(self: Stream.Stream<Source, E, R>) => Stream.Stream<RunEvent, E | Schema.SchemaError, R>;
+//#endregion
+export { Config, Options, Source, State, initial, step, Projection_d_exports as t, toRunEvents };
+//# sourceMappingURL=Projection.d.mts.map

package/dist/Projection.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Projection.d.mts","names":[],"sources":["../src/Projection.ts"],"mappings":";;;;;;;;;;KAiBY,SAAS,KAAK,YAAY,UAAU,YAAY,MAAM;cAErD,SAAO,OAAA;;;;;;;;;KASR,iBAAiB,QAAQ;;KAGzB,SAAS;WACV,UAAU,KAAK;;cAGb,OAAK,OAAA;;;;;;KAMN,eAAe,MAAM;cAEpB,SAAS;KAEjB,iBAAiB,OAAO,cAAc;;cA8C9B,OAAI,QACN,YAAM,GACX,OAAK,OAAS,WAAS,OAAO,OAAO,MAAM,OAAO;;;;;cA6C3C,cAAW,QACb,YACR,GAAG,GAAC,MAAQ,OAAO,OAAO,QAAQ,GAAG,OAAK,OAAO,OAAO,UAAU,IAAI,OAAO,aAAa"}