@effect-uai/ui 0.0.0-stage → 0.19.0-dev-20261109183959

package/dist/UiContract.mjs

@@ -0,0 +1,229 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Data as Data$1, Interrupt, Live, ObjectDone, Outcome, RunCompleted, RunInterrupted, ToolApprovalRequested, ToolCallReady, ToolPartial, ToolResult, envelopeFields, outcome, plainEvents } from "./RunEvent.mjs";
+import { contentBlocks, dataBlock, objectBlock, schema, toolBlock, unnamedObject } from "./RunView.mjs";
+import { State, UserContent } from "./Thread.mjs";
+import { Effect, HashMap, Match, Option, Result, Schema } from "effect";
+import * as Content from "@effect-uai/core/Content";
+import * as ToolOutput from "@effect-uai/core/ToolOutput";
+//#region src/UiContract.ts
+/**
+* A typed contract between server and client, built from Schemas only, so
+* both sides import the same value (the pattern of Effect's `HttpApi`). The
+* wire stays JSON; the client decodes each envelope once on arrival, and from
+* then on the state holds decoded values: a tool block narrowed by `name`
+* has its tool's input and output types, a `Date` is a `Date`.
+*
+*   const ChatUi = UiContract.make({ tools: [GetWeather], live: { metrics: Metrics } })
+*
+*   // server: typed payload events (tool outputs are encoded by the Toolkit)
+*   yield* ChatUi.live("metrics", { tokps: 42 })
+*
+*   // client: the state is typed by the contract
+*   const chat = Atoms.thread({ contract: ChatUi, transport, busy: "block" })
+*
+* The types list the contract's names only, so narrowing by name is exact. A
+* name the contract doesn't list (a newer server rolling out a tool) still
+* arrives, as JSON, but the types don't mention it: a `switch (b.name)` skips
+* it. A listed name whose payload doesn't decode fails the envelope: that is
+* a contract violation, not data to show.
+*
+* A tool is a core `Tool` or a shared spec (`as const`, schemas only). Its
+* result is `Success { value } | Failure { error }`: the error is the tool's
+* `failureSchema` (app closings like `ToolDecision.Denied` included) or core's
+* `ToolOutput.CoreError`.
+* Without `outputSchema`, values are a `Content.Value` (media as classes).
+*/
+var UiContract_exports = /* @__PURE__ */ __exportAll({ make: () => make });
+const json = (schema) => Schema.toCodecJson(schema);
+const listed = (name) => Schema.Literal(name);
+const unlisted = (names) => Schema.String.check(Schema.makeFilter((name) => !names.includes(name)));
+const isCodec = (schema) => Schema.isSchema(schema);
+const inputCodec = (tool) => {
+	const schema = tool.inputSchema;
+	if (isCodec(schema)) return json(schema);
+	return Schema.declare((u) => {
+		const result = schema["~standard"].validate(u);
+		return !(result instanceof Promise) && result.issues === void 0;
+	});
+};
+const isAnything = (tool) => tool?.outputSchema === void 0 || tool.outputSchema === Content.Value;
+const outputCodec = (tool) => isAnything(tool) ? ToolOutput.ValueParts : tool?.outputSchema ?? ToolOutput.ValueParts;
+const encodeParts = Schema.encodeEffect(Schema.Array(ToolOutput.PartJson));
+const failureCodec = (tool) => tool?.failureSchema === void 0 ? ToolOutput.CoreError : Schema.Union([tool.failureSchema, ToolOutput.CoreError]);
+const entries = (record) => Object.entries(record ?? {});
+const toJson = Schema.decodeUnknownEffect(Schema.Json);
+const toOutcome = Schema.decodeUnknownEffect(Outcome);
+function make(spec) {
+	const tools = spec.tools ?? [];
+	const objects = entries(spec.objects);
+	const data = entries(spec.data);
+	const live = entries(spec.live);
+	const toolNames = tools.map((t) => t.name);
+	const metadata = spec.metadata === void 0 ? Schema.Json : json(spec.metadata);
+	const resultCodec = (tool) => outcome(outputCodec(tool), failureCodec(tool));
+	const codecsOf = (tool) => ({
+		output: outputCodec(tool),
+		result: resultCodec(tool),
+		anything: isAnything(tool)
+	});
+	const unlistedCodecs = codecsOf(void 0);
+	const codecsByName = HashMap.fromIterable(tools.map((t) => [t.name, codecsOf(t)]));
+	const codecs = (name) => Option.getOrElse(HashMap.get(codecsByName, name), () => unlistedCodecs);
+	const interrupt = Schema.Union([...tools.map((t) => Schema.Struct({
+		...Interrupt.fields,
+		name: listed(t.name),
+		input: inputCodec(t)
+	})), Schema.Struct({
+		...Interrupt.fields,
+		name: unlisted(toolNames)
+	})]);
+	const toolInput = (event) => Schema.Union([...tools.map((t) => Schema.Struct({
+		...event.fields,
+		name: listed(t.name),
+		input: inputCodec(t)
+	})), Schema.Struct({
+		...event.fields,
+		name: unlisted(toolNames)
+	})]);
+	const named = (event, members) => Schema.Union([...members.map(([name, schema]) => Schema.Struct({
+		...event.fields,
+		name: listed(name),
+		value: json(schema)
+	})), Schema.Struct({
+		...event.fields,
+		name: unlisted(members.map(([name]) => name))
+	})]);
+	const event = Schema.Union([
+		...plainEvents.map((e) => Schema.toType(e)),
+		Schema.Struct({
+			...RunCompleted.fields,
+			metadata: Schema.optional(metadata)
+		}),
+		Schema.Struct({
+			...RunInterrupted.fields,
+			interrupts: Schema.Array(interrupt)
+		}),
+		Schema.Union([...objects.map(([name, schema]) => Schema.Struct({
+			...ObjectDone.fields,
+			name: listed(name),
+			value: json(schema)
+		})), Schema.Struct({
+			...ObjectDone.fields,
+			name: Schema.optional(unlisted(objects.map(([name]) => name)))
+		})]),
+		toolInput(ToolCallReady),
+		toolInput(ToolApprovalRequested),
+		Schema.Union([...tools.map((t) => Schema.Struct({
+			...ToolPartial.fields,
+			name: listed(t.name),
+			value: outputCodec(t)
+		})), Schema.Struct({
+			...ToolPartial.fields,
+			name: unlisted(toolNames)
+		})]),
+		Schema.Union([...tools.map((t) => Schema.Struct({
+			...ToolResult.fields,
+			name: listed(t.name),
+			result: resultCodec(t)
+		})), Schema.Struct({
+			...ToolResult.fields,
+			name: unlisted(toolNames)
+		})]),
+		named(Data$1, data),
+		named(Live, live)
+	]);
+	const envelope = Schema.Struct({
+		...envelopeFields,
+		event
+	});
+	const view = schema({
+		block: Schema.Union([
+			...contentBlocks,
+			...tools.map((t) => toolBlock(listed(t.name), inputCodec(t), outputCodec(t), failureCodec(t))),
+			toolBlock(unlisted(toolNames), Schema.Json, Schema.Json, Schema.Json),
+			...objects.map(([name, schema]) => objectBlock(listed(name), json(schema))),
+			objectBlock(unlisted(objects.map(([name]) => name)), Schema.Json),
+			unnamedObject,
+			...data.map(([name, schema]) => dataBlock(listed(name), json(schema))),
+			dataBlock(unlisted(data.map(([name]) => name)), Schema.Json)
+		]),
+		interrupt,
+		live: Schema.Struct(Object.fromEntries(live.map(([name, schema]) => [name, Schema.optionalKey(json(schema))]))),
+		metadata
+	});
+	const codecOf = (members, name) => members.find(([n]) => n === name)?.[1];
+	const encode = (schema, value) => Schema.encodeUnknownEffect(schema === void 0 ? Schema.Json : json(schema))(value).pipe(Effect.flatMap(toJson));
+	const toolResult = (call, outcome) => Schema.encodeUnknownEffect(codecs(call.name).result)(outcome).pipe(Effect.flatMap(toOutcome), Effect.map((result) => ({
+		type: "tool-result",
+		callId: call.call_id,
+		name: call.name,
+		result
+	})));
+	return {
+		decode: Schema.decodeUnknownEffect(envelope),
+		Envelope: envelope,
+		RunView: view,
+		Thread: State(UserContent, view, view),
+		data: (name, value, options) => encode(codecOf(data, name), value).pipe(Effect.map((encoded) => options?.id === void 0 ? {
+			type: "data",
+			name,
+			value: encoded
+		} : {
+			type: "data",
+			name,
+			value: encoded,
+			id: options.id
+		})),
+		live: (name, value) => encode(codecOf(live, name), value).pipe(Effect.map((encoded) => ({
+			type: "live",
+			name,
+			value: encoded
+		}))),
+		metadata: (value) => encode(spec.metadata, value),
+		toolEvent: (event) => Match.value(event).pipe(Match.tagsExhaustive({
+			Partial: (e) => Schema.encodeUnknownEffect(codecs(e.tool).output)(e.value).pipe(Effect.flatMap(toJson), Effect.map((value) => ({
+				type: "tool-partial",
+				callId: e.call_id,
+				name: e.tool,
+				value
+			}))),
+			Output: (e) => toolResult({
+				call_id: e.call_id,
+				name: e.tool
+			}, Result.match(e.result, {
+				onSuccess: (value) => ({
+					_tag: "Success",
+					value
+				}),
+				onFailure: (error) => ({
+					_tag: "Failure",
+					error
+				})
+			}))
+		})),
+		toolOutput: (item, name) => Match.value(item).pipe(Match.when({ isError: true }, (o) => Effect.map(ToolOutput.encoded(o.output), (error) => ({
+			_tag: "Failure",
+			error
+		}))), Match.orElse((o) => Effect.map(codecs(name).anything ? encodeParts(o.output) : ToolOutput.encoded(o.output), (value) => ({
+			_tag: "Success",
+			value
+		}))), Effect.flatMap(toOutcome), Effect.map((result) => ({
+			type: "tool-result",
+			callId: item.call_id,
+			name,
+			result
+		}))),
+		success: (call, value) => toolResult(call, {
+			_tag: "Success",
+			value
+		}),
+		failure: (call, error) => toolResult(call, {
+			_tag: "Failure",
+			error
+		})
+	};
+}
+//#endregion
+export { make, UiContract_exports as t };
+
+//# sourceMappingURL=UiContract.mjs.map

package/dist/UiContract.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"UiContract.mjs","names":["Event.Outcome","Event.outcome","Event.ToolCallReady","Event.ToolApprovalRequested","Event.Data","Event.Live","Event.envelopeFields","RunView.schema","RunView.contentBlocks","RunView.toolBlock","RunView.objectBlock","RunView.unnamedObject","RunView.dataBlock","Thread.State","Thread.UserContent"],"sources":["../src/UiContract.ts"],"sourcesContent":["/**\n * A typed contract between server and client, built from Schemas only, so\n * both sides import the same value (the pattern of Effect's `HttpApi`). The\n * wire stays JSON; the client decodes each envelope once on arrival, and from\n * then on the state holds decoded values: a tool block narrowed by `name`\n * has its tool's input and output types, a `Date` is a `Date`.\n *\n *   const ChatUi = UiContract.make({ tools: [GetWeather], live: { metrics: Metrics } })\n *\n *   // server: typed payload events (tool outputs are encoded by the Toolkit)\n *   yield* ChatUi.live(\"metrics\", { tokps: 42 })\n *\n *   // client: the state is typed by the contract\n *   const chat = Atoms.thread({ contract: ChatUi, transport, busy: \"block\" })\n *\n * The types list the contract's names only, so narrowing by name is exact. A\n * name the contract doesn't list (a newer server rolling out a tool) still\n * arrives, as JSON, but the types don't mention it: a `switch (b.name)` skips\n * it. A listed name whose payload doesn't decode fails the envelope: that is\n * a contract violation, not data to show.\n *\n * A tool is a core `Tool` or a shared spec (`as const`, schemas only). Its\n * result is `Success { value } | Failure { error }`: the error is the tool's\n * `failureSchema` (app closings like `ToolDecision.Denied` included) or core's\n * `ToolOutput.CoreError`.\n * Without `outputSchema`, values are a `Content.Value` (media as classes).\n */\nimport * as Content from \"@effect-uai/core/Content\"\nimport type * as Items from \"@effect-uai/core/Items\"\nimport type * as Tool from \"@effect-uai/core/Tool\"\nimport type { ToolInputSchema } from \"@effect-uai/core/Tool\"\nimport type * as ToolEvent from \"@effect-uai/core/ToolEvent\"\nimport * as ToolOutput from \"@effect-uai/core/ToolOutput\"\nimport { Effect, HashMap, Match, Option, Result, Schema } from \"effect\"\nimport * as Event from \"./RunEvent.js\"\nimport type { Envelope, Json, Payloads as AnyPayloads, RunEvent, ToolPayload } from \"./RunEvent.js\"\nimport * as RunView from \"./RunView.js\"\nimport * as Thread from \"./Thread.js\"\n\ntype AnyCodec = Schema.Codec<any, any, never, never>\n// Tool values reach history and the UI through the same schema, so it must encode to JSON.\ntype JsonCodec = Schema.Codec<any, Schema.Json, never, never>\n\n/** A tool as the contract sees it: a core `Tool` or a shared spec (`as const`). */\nexport type ToolSpec = {\n  readonly name: string\n  readonly inputSchema: AnyCodec | ToolInputSchema<any>\n  readonly outputSchema?: JsonCodec\n  readonly failureSchema?: JsonCodec\n}\n\nexport type Spec = {\n  readonly tools?: ReadonlyArray<ToolSpec>\n  readonly objects?: Readonly<Record<string, AnyCodec>>\n  readonly data?: Readonly<Record<string, AnyCodec>>\n  readonly live?: Readonly<Record<string, AnyCodec>>\n  readonly metadata?: AnyCodec\n}\n\ntype InputOf<S> = S extends Schema.Top ? S[\"Type\"] : S extends ToolInputSchema<infer A> ? A : Json\n// A core `Tool` carries its types; a spec has them in its schemas. Without\n// `outputSchema` a tool returns a `Content.Value`, and that is what arrives.\ntype CoreTool = { readonly _tag: \"LocalTool\" | \"DeclaredTool\" }\ntype OutputOf<T> = T extends CoreTool\n  ? Tool.ToolOutput<T>\n  : T extends { readonly outputSchema: infer O extends Schema.Top }\n    ? O[\"Type\"]\n    : Content.Value\ntype FailureOf<T> = T extends CoreTool\n  ? Tool.ToolFailure<T>\n  : T extends { readonly failureSchema: infer F extends Schema.Top }\n    ? F[\"Type\"]\n    : never\ntype ToolOf<T> = T extends ToolSpec\n  ? {\n      readonly name: T[\"name\"]\n      readonly input: InputOf<T[\"inputSchema\"]>\n      readonly output: OutputOf<T>\n      readonly failure: FailureOf<T> | ToolOutput.CoreError\n    }\n  : never\ntype ElementOf<T> = T extends ReadonlyArray<infer E> ? E : never\ntype NamedOf<M> = {\n  readonly [K in keyof M & string]: {\n    readonly name: K\n    readonly value: M[K] extends Schema.Top ? M[K][\"Type\"] : never\n  }\n}[keyof M & string]\n/** The payload types a spec describes: its listed names only. */\nexport type PayloadsOf<S extends Spec> = {\n  readonly tool: ToolOf<ElementOf<S[\"tools\"]>>\n  readonly object: NamedOf<S[\"objects\"]>\n  readonly data: NamedOf<S[\"data\"]>\n  readonly live: NamedOf<S[\"live\"]>\n  readonly metadata: S[\"metadata\"] extends Schema.Top ? S[\"metadata\"][\"Type\"] : Json\n}\n\ntype NameOf<T> = T extends { readonly name: infer N } ? N : never\ntype ValueOf<T, N> =\n  Extract<T, { readonly name: N }> extends { readonly value: infer V } ? V : never\ntype ToolField<T, N, K extends \"output\" | \"failure\"> =\n  Extract<T, { readonly name: N }> extends infer X extends ToolPayload ? X[K] : never\n\n/** The call an app closes itself: its id and the tool's name. */\nexport type Call<N extends string = string> = { readonly call_id: string; readonly name: N }\n\n/**\n * A contract's payload types, for the generic folds:\n * `Thread.presetFor<UiContract.Payloads<typeof ChatUi>>()`.\n */\nexport type Payloads<C> = C extends UiContract<infer P> ? P : never\n\nexport interface UiContract<P extends AnyPayloads> {\n  /** Decode a wire envelope (as `Client` reads it) into a typed one. */\n  decode(envelope: Envelope): Effect.Effect<Envelope<P>, Schema.SchemaError>\n  /** Typed envelope ⇄ wire envelope. */\n  readonly Envelope: Schema.Codec<Envelope<P>, Envelope>\n  /** A typed run view ⇄ the untyped one, for persisting or a framework's model. */\n  readonly RunView: Schema.Codec<RunView.RunView<P>, RunView.RunView>\n  /** A typed `Thread` ⇄ the untyped one. */\n  readonly Thread: Schema.Codec<Thread.Thread<P>, Thread.Thread>\n  /** Server: a `data` event with its value encoded for the wire. */\n  data<N extends NameOf<P[\"data\"]>>(\n    name: N,\n    value: ValueOf<P[\"data\"], N>,\n    options?: { readonly id?: string },\n  ): Effect.Effect<RunEvent, Schema.SchemaError>\n  /** Server: a `live` event with its value encoded for the wire. */\n  live<N extends NameOf<P[\"live\"]>>(\n    name: N,\n    value: ValueOf<P[\"live\"], N>,\n  ): Effect.Effect<RunEvent, Schema.SchemaError>\n  /** Server: run metadata encoded for `run-completed`. */\n  metadata(value: P[\"metadata\"]): Effect.Effect<Json, Schema.SchemaError>\n  /** Server: a toolkit event (`Toolkit.run`) encoded with the tool's schemas. */\n  toolEvent(event: ToolEvent.ToolEvent): Effect.Effect<RunEvent, Schema.SchemaError>\n  /** Server: a history item (already encoded) as the `tool-result` of tool `name`. */\n  toolOutput(item: Items.ToolCallOutput, name: string): Effect.Effect<RunEvent, Schema.SchemaError>\n  /** Server: close a call with a value of its tool's output (e.g. supplied by the user). */\n  success<N extends NameOf<P[\"tool\"]>>(\n    call: Call<N>,\n    value: ToolField<P[\"tool\"], N, \"output\">,\n  ): Effect.Effect<RunEvent, Schema.SchemaError>\n  /** Server: close a call with an error (e.g. the app's `Denied`). */\n  failure<N extends NameOf<P[\"tool\"]>>(\n    call: Call<N>,\n    error: ToolField<P[\"tool\"], N, \"failure\">,\n  ): Effect.Effect<RunEvent, Schema.SchemaError>\n}\n\n// ---------------------------------------------------------------------------\n// Runtime: one schema member per listed name, plus a fallback for the rest\n// ---------------------------------------------------------------------------\n\nconst json = <S extends Schema.Top>(schema: S) => Schema.toCodecJson(schema)\nconst listed = (name: string) => Schema.Literal(name)\nconst unlisted = (names: ReadonlyArray<string>) =>\n  Schema.String.check(Schema.makeFilter((name: string) => !names.includes(name)))\n\n/** A payload codec: decodes from JSON without services. */\ntype PayloadCodec = Schema.Codec<unknown, unknown, never, never>\n\n// A core `Tool` built from an Effect Schema keeps it (`fromEffectSchema`), so it decodes too.\nconst isCodec = (schema: ToolSpec[\"inputSchema\"]): schema is AnyCodec => Schema.isSchema(schema)\n\n// Effect Schemas decode the model's JSON; other Standard Schemas validate it as is.\nconst inputCodec = (tool: ToolSpec): PayloadCodec => {\n  const schema = tool.inputSchema\n  if (isCodec(schema)) return json(schema)\n  return Schema.declare((u: unknown): u is Json => {\n    const result = schema[\"~standard\"].validate(u)\n    return !(result instanceof Promise) && result.issues === undefined\n  })\n}\n// \"Anything\": a tool typed `Content.Value`, or a name the contract doesn't list.\nconst isAnything = (tool: ToolSpec | undefined): boolean =>\n  tool?.outputSchema === undefined || tool.outputSchema === Content.Value\n\n// The tool's own schemas, as `Toolkit.output` uses them: they encode to JSON, so\n// the UI and history agree by construction (no `toCodecJson` on top). \"Anything\"\n// travels as typed parts, so JSON can't be mistaken for media.\nconst outputCodec = (tool: ToolSpec | undefined): PayloadCodec =>\n  isAnything(tool) ? ToolOutput.ValueParts : (tool?.outputSchema ?? ToolOutput.ValueParts)\n\nconst encodeParts = Schema.encodeEffect(Schema.Array(ToolOutput.PartJson))\n\nconst failureCodec = (tool: ToolSpec | undefined): PayloadCodec =>\n  tool?.failureSchema === undefined\n    ? ToolOutput.CoreError\n    : Schema.Union([tool.failureSchema, ToolOutput.CoreError])\n\nconst entries = (record: Readonly<Record<string, AnyCodec>> | undefined) =>\n  Object.entries(record ?? {})\n\n/** Encoded loosely; `make`'s signature carries the types. */\ntype Loose = {\n  decode(envelope: Envelope): Effect.Effect<unknown, Schema.SchemaError>\n  readonly Envelope: Schema.Top\n  readonly RunView: Schema.Top\n  readonly Thread: Schema.Top\n  data(\n    name: string,\n    value: unknown,\n    options?: { readonly id?: string },\n  ): Effect.Effect<RunEvent, Schema.SchemaError>\n  live(name: string, value: unknown): Effect.Effect<RunEvent, Schema.SchemaError>\n  metadata(value: unknown): Effect.Effect<Json, Schema.SchemaError>\n  toolEvent(event: ToolEvent.ToolEvent): Effect.Effect<RunEvent, Schema.SchemaError>\n  toolOutput(item: Items.ToolCallOutput, name: string): Effect.Effect<RunEvent, Schema.SchemaError>\n  success(call: Call, value: unknown): Effect.Effect<RunEvent, Schema.SchemaError>\n  failure(call: Call, error: unknown): Effect.Effect<RunEvent, Schema.SchemaError>\n}\n\nconst toJson = Schema.decodeUnknownEffect(Schema.Json)\nconst toOutcome = Schema.decodeUnknownEffect(Event.Outcome)\n\n/**\n * Build a contract. Tool names must be literal types: pass core `Tool`s or\n * specs declared `as const`.\n */\nexport function make<const S extends Spec>(spec: S): UiContract<PayloadsOf<S>>\nexport function make(spec: Spec): Loose {\n  const tools = spec.tools ?? []\n  const objects = entries(spec.objects)\n  const data = entries(spec.data)\n  const live = entries(spec.live)\n  const toolNames = tools.map((t) => t.name)\n  const metadata = spec.metadata === undefined ? Schema.Json : json(spec.metadata)\n  const resultCodec = (tool: ToolSpec | undefined) =>\n    Event.outcome(outputCodec(tool), failureCodec(tool))\n  // Built once per tool; an unlisted name falls back to the tool-less codecs.\n  const codecsOf = (tool: ToolSpec | undefined) => ({\n    output: outputCodec(tool),\n    result: resultCodec(tool),\n    anything: isAnything(tool),\n  })\n  const unlistedCodecs = codecsOf(undefined)\n  const codecsByName = HashMap.fromIterable(tools.map((t) => [t.name, codecsOf(t)] as const))\n  const codecs = (name: string) =>\n    Option.getOrElse(HashMap.get(codecsByName, name), () => unlistedCodecs)\n\n  const interrupt = Schema.Union([\n    ...tools.map((t) =>\n      Schema.Struct({ ...Event.Interrupt.fields, name: listed(t.name), input: inputCodec(t) }),\n    ),\n    Schema.Struct({ ...Event.Interrupt.fields, name: unlisted(toolNames) }),\n  ])\n\n  const toolInput = (event: typeof Event.ToolCallReady | typeof Event.ToolApprovalRequested) =>\n    Schema.Union([\n      ...tools.map((t) =>\n        Schema.Struct({ ...event.fields, name: listed(t.name), input: inputCodec(t) }),\n      ),\n      Schema.Struct({ ...event.fields, name: unlisted(toolNames) }),\n    ])\n\n  const named = (\n    event: typeof Event.Data | typeof Event.Live,\n    members: ReadonlyArray<readonly [string, AnyCodec]>,\n  ) =>\n    Schema.Union([\n      ...members.map(([name, schema]) =>\n        Schema.Struct({ ...event.fields, name: listed(name), value: json(schema) }),\n      ),\n      Schema.Struct({ ...event.fields, name: unlisted(members.map(([name]) => name)) }),\n    ])\n\n  const event = Schema.Union([\n    ...Event.plainEvents.map((e) => Schema.toType(e)),\n    Schema.Struct({ ...Event.RunCompleted.fields, metadata: Schema.optional(metadata) }),\n    Schema.Struct({ ...Event.RunInterrupted.fields, interrupts: Schema.Array(interrupt) }),\n    Schema.Union([\n      ...objects.map(([name, schema]) =>\n        Schema.Struct({ ...Event.ObjectDone.fields, name: listed(name), value: json(schema) }),\n      ),\n      Schema.Struct({\n        ...Event.ObjectDone.fields,\n        name: Schema.optional(unlisted(objects.map(([name]) => name))),\n      }),\n    ]),\n    toolInput(Event.ToolCallReady),\n    toolInput(Event.ToolApprovalRequested),\n    Schema.Union([\n      ...tools.map((t) =>\n        Schema.Struct({ ...Event.ToolPartial.fields, name: listed(t.name), value: outputCodec(t) }),\n      ),\n      Schema.Struct({ ...Event.ToolPartial.fields, name: unlisted(toolNames) }),\n    ]),\n    Schema.Union([\n      ...tools.map((t) =>\n        Schema.Struct({ ...Event.ToolResult.fields, name: listed(t.name), result: resultCodec(t) }),\n      ),\n      Schema.Struct({ ...Event.ToolResult.fields, name: unlisted(toolNames) }),\n    ]),\n    named(Event.Data, data),\n    named(Event.Live, live),\n  ])\n  const envelope = Schema.Struct({ ...Event.envelopeFields, event })\n\n  const view = RunView.schema({\n    block: Schema.Union([\n      ...RunView.contentBlocks,\n      ...tools.map((t) =>\n        RunView.toolBlock(listed(t.name), inputCodec(t), outputCodec(t), failureCodec(t)),\n      ),\n      RunView.toolBlock(unlisted(toolNames), Schema.Json, Schema.Json, Schema.Json),\n      ...objects.map(([name, schema]) => RunView.objectBlock(listed(name), json(schema))),\n      RunView.objectBlock(unlisted(objects.map(([name]) => name)), Schema.Json),\n      RunView.unnamedObject,\n      ...data.map(([name, schema]) => RunView.dataBlock(listed(name), json(schema))),\n      RunView.dataBlock(unlisted(data.map(([name]) => name)), Schema.Json),\n    ]),\n    interrupt,\n    // Unlisted live values are transient and untyped: the schema keeps listed ones only.\n    live: Schema.Struct(\n      Object.fromEntries(live.map(([name, schema]) => [name, Schema.optionalKey(json(schema))])),\n    ),\n    metadata,\n  })\n\n  const codecOf = (members: ReadonlyArray<readonly [string, AnyCodec]>, name: string) =>\n    members.find(([n]) => n === name)?.[1]\n  const encode = (schema: AnyCodec | undefined, value: unknown) =>\n    Schema.encodeUnknownEffect(schema === undefined ? Schema.Json : json(schema))(value).pipe(\n      Effect.flatMap(toJson),\n    )\n  const toolResult = (call: Call, outcome: Event.Outcome<unknown, unknown>) =>\n    Schema.encodeUnknownEffect(codecs(call.name).result)(outcome).pipe(\n      Effect.flatMap(toOutcome),\n      Effect.map((result): RunEvent => ({\n        type: \"tool-result\",\n        callId: call.call_id,\n        name: call.name,\n        result,\n      })),\n    )\n\n  return {\n    decode: Schema.decodeUnknownEffect(envelope),\n    Envelope: envelope,\n    RunView: view,\n    Thread: Thread.State(Thread.UserContent, view, view),\n    data: (name, value, options) =>\n      encode(codecOf(data, name), value).pipe(\n        Effect.map((encoded): RunEvent =>\n          options?.id === undefined\n            ? { type: \"data\", name, value: encoded }\n            : { type: \"data\", name, value: encoded, id: options.id },\n        ),\n      ),\n    live: (name, value) =>\n      encode(codecOf(live, name), value).pipe(\n        Effect.map((encoded): RunEvent => ({ type: \"live\", name, value: encoded })),\n      ),\n    metadata: (value) => encode(spec.metadata, value),\n    toolEvent: (event) =>\n      Match.value(event).pipe(\n        Match.tagsExhaustive({\n          Partial: (e) =>\n            Schema.encodeUnknownEffect(codecs(e.tool).output)(e.value).pipe(\n              Effect.flatMap(toJson),\n              Effect.map((value): RunEvent => ({\n                type: \"tool-partial\",\n                callId: e.call_id,\n                name: e.tool,\n                value,\n              })),\n            ),\n          Output: (e) =>\n            toolResult(\n              { call_id: e.call_id, name: e.tool },\n              Result.match(e.result, {\n                onSuccess: (value): Event.Outcome<unknown, unknown> => ({ _tag: \"Success\", value }),\n                onFailure: (error): Event.Outcome<unknown, unknown> => ({ _tag: \"Failure\", error }),\n              }),\n            ),\n        }),\n      ),\n    // The item holds the encoded value: \"anything\" goes as its parts, the rest as the JSON they encode.\n    toolOutput: (item, name) =>\n      Match.value(item).pipe(\n        Match.when({ isError: true }, (o) =>\n          Effect.map(ToolOutput.encoded(o.output), (error) => ({ _tag: \"Failure\", error })),\n        ),\n        Match.orElse((o) =>\n          Effect.map(\n            codecs(name).anything ? encodeParts(o.output) : ToolOutput.encoded(o.output),\n            (value) => ({ _tag: \"Success\", value }),\n          ),\n        ),\n        Effect.flatMap(toOutcome),\n        Effect.map((result): RunEvent => ({\n          type: \"tool-result\",\n          callId: item.call_id,\n          name,\n          result,\n        })),\n      ),\n    success: (call, value) => toolResult(call, { _tag: \"Success\", value }),\n    failure: (call, error) => toolResult(call, { _tag: \"Failure\", error }),\n  }\n}\n"],"mappings":"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"}

package/dist/index.d.mts

@@ -0,0 +1,12 @@
+import { t as RunEvent_d_exports } from "./RunEvent.mjs";
+import { s as Input_d_exports } from "./Input-Cz-Kxusm.mjs";
+import { u as RunView_d_exports } from "./RunView-nHfJwN8t.mjs";
+import { l as Thread_d_exports } from "./Thread-CAXsjhpX.mjs";
+import { n as Client_d_exports } from "./Client-C9UYN_VK.mjs";
+import { t as Transport_d_exports } from "./Transport.mjs";
+import { t as UiContract_d_exports } from "./UiContract.mjs";
+import { t as Atoms_d_exports } from "./Atoms.mjs";
+import { t as Projection_d_exports } from "./Projection.mjs";
+import { t as Run_d_exports } from "./Run.mjs";
+import { t as SseEncoding_d_exports } from "./SseEncoding.mjs";
+export { Atoms_d_exports as Atoms, Client_d_exports as Client, Input_d_exports as Input, Projection_d_exports as Projection, Run_d_exports as Run, RunEvent_d_exports as RunEvent, RunView_d_exports as RunView, SseEncoding_d_exports as SseEncoding, Thread_d_exports as Thread, Transport_d_exports as Transport, UiContract_d_exports as UiContract };

package/dist/index.mjs

@@ -0,0 +1,12 @@
+import { t as RunEvent_exports } from "./RunEvent.mjs";
+import { t as Input_exports } from "./Input.mjs";
+import { t as RunView_exports } from "./RunView.mjs";
+import { t as Thread_exports } from "./Thread.mjs";
+import { t as Atoms_exports } from "./Atoms.mjs";
+import { t as SseEncoding_exports } from "./SseEncoding.mjs";
+import { t as Client_exports } from "./Client.mjs";
+import { t as Projection_exports } from "./Projection.mjs";
+import { t as Run_exports } from "./Run.mjs";
+import { t as Transport_exports } from "./Transport.mjs";
+import { t as UiContract_exports } from "./UiContract.mjs";
+export { Atoms_exports as Atoms, Client_exports as Client, Input_exports as Input, Projection_exports as Projection, Run_exports as Run, RunEvent_exports as RunEvent, RunView_exports as RunView, SseEncoding_exports as SseEncoding, Thread_exports as Thread, Transport_exports as Transport, UiContract_exports as UiContract };

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/package.json

@@ -1,6 +1,102 @@
 {
   "name": "@effect-uai/ui",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.19.0-dev-20261109183959",
+  "description": "Agentic UI primitives for @effect-uai/core: a resumable run-event protocol, projection, client folds and Effect atoms.",
+  "keywords": [
+    "agents",
+    "ai",
+    "chat",
+    "effect",
+    "sse",
+    "streaming",
+    "ui"
+  ],
+  "homepage": "https://github.com/betalyra/effect-uai/tree/main/packages/ui",
+  "bugs": {
+    "url": "https://github.com/betalyra/effect-uai/issues"
+  },
+  "license": "MIT",
+  "author": "Betalyra",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/betalyra/effect-uai",
+    "directory": "packages/ui"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./RunEvent": {
+      "types": "./dist/RunEvent.d.mts",
+      "import": "./dist/RunEvent.mjs"
+    },
+    "./Input": {
+      "types": "./dist/Input.d.mts",
+      "import": "./dist/Input.mjs"
+    },
+    "./Projection": {
+      "types": "./dist/Projection.d.mts",
+      "import": "./dist/Projection.mjs"
+    },
+    "./Run": {
+      "types": "./dist/Run.d.mts",
+      "import": "./dist/Run.mjs"
+    },
+    "./RunView": {
+      "types": "./dist/RunView.d.mts",
+      "import": "./dist/RunView.mjs"
+    },
+    "./Thread": {
+      "types": "./dist/Thread.d.mts",
+      "import": "./dist/Thread.mjs"
+    },
+    "./UiContract": {
+      "types": "./dist/UiContract.d.mts",
+      "import": "./dist/UiContract.mjs"
+    },
+    "./SseEncoding": {
+      "types": "./dist/SseEncoding.d.mts",
+      "import": "./dist/SseEncoding.mjs"
+    },
+    "./Client": {
+      "types": "./dist/Client.d.mts",
+      "import": "./dist/Client.mjs"
+    },
+    "./Transport": {
+      "types": "./dist/Transport.d.mts",
+      "import": "./dist/Transport.mjs"
+    },
+    "./Atoms": {
+      "types": "./dist/Atoms.d.mts",
+      "import": "./dist/Atoms.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@effect/vitest": "4.1.2",
+    "effect": "4.1.2",
+    "typescript": "^7.0.2",
+    "@effect-uai/core": "0.19.0-dev-20261109183959"
+  },
+  "peerDependencies": {
+    "@effect-uai/core": "0.19.0-dev-20261109183959",
+    "effect": ">=4.0.1 <5.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  }
 }

package/src/Atoms.test.ts

@@ -0,0 +1,163 @@
+import { describe, it } from "@effect/vitest"
+import { Effect, Fiber, Option, PubSub, Ref, Stream } from "effect"
+import { SecureRandom } from "effect/crypto"
+import { Atom, AtomRegistry } from "effect/reactivity"
+import { expect } from "vitest"
+import * as Atoms from "./Atoms.js"
+import * as Input from "./Input.js"
+import * as Run from "./Run.js"
+import { type Envelope, type InputId, RunId, type RunEvent, StreamId } from "./RunEvent.js"
+import type * as Thread from "./Thread.js"
+import * as Transport from "./Transport.js"
+
+const runtime = Atom.runtime(SecureRandom.layerWebCrypto)
+
+const reply = (inputId: InputId): ReadonlyArray<RunEvent> => [
+  { type: "run-started", runId: RunId.make("r1"), inputs: [inputId], protocol: 2 },
+  { type: "text-delta", text: "Hello" },
+  { type: "run-completed" },
+]
+
+const finished = (registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<any>) =>
+  AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true })
+
+const streaming = (
+  registry: AtomRegistry.AtomRegistry,
+  chat: { readonly state: Atom.Atom<Thread.Thread> },
+) =>
+  AtomRegistry.toStream(registry, chat.state).pipe(
+    Stream.filter((t) => t.active?.status === "streaming"),
+    Stream.runHead,
+  )
+
+describe("Atoms.thread", () => {
+  it.effect(
+    "submit folds the run into the thread and settles it, observed only through state",
+    () =>
+      Effect.gen(function* () {
+        const chat = Atoms.thread({
+          runtime,
+          busy: "block",
+          // Async frames: the run outlives the tick `submit` was called in.
+          transport: Transport.local((input: Input.Sent) =>
+            Stream.fromIterable(reply(input.id)).pipe(Stream.tap(() => Effect.yieldNow)),
+          ),
+        })
+        const registry = AtomRegistry.make()
+        const settled = yield* AtomRegistry.toStream(registry, chat.state).pipe(
+          Stream.filter((t) => t.messages.length === 2),
+          Stream.runHead,
+          Effect.forkChild,
+        )
+        registry.set(chat.submit, Input.submit("Hi"))
+        const thread = yield* Fiber.join(settled).pipe(Effect.map(Option.getOrThrow))
+
+        expect(thread.active).toBeNull()
+        const assistant = thread.messages[1]
+        expect(assistant?.role === "assistant" && assistant.value.status).toBe("completed")
+      }),
+  )
+
+  it.effect("stop interrupts a direct run and settles it locally as stopped", () =>
+    Effect.gen(function* () {
+      const chat = Atoms.thread({
+        runtime,
+        busy: "block",
+        transport: Transport.local((input: Input.Sent) =>
+          Stream.fromIterable(reply(input.id).slice(0, 2)).pipe(Stream.concat(Stream.never)),
+        ),
+      })
+      const registry = AtomRegistry.make()
+      registry.set(chat.submit, Input.submit("Hi"))
+      yield* streaming(registry, chat)
+      registry.set(chat.stop, undefined)
+      yield* finished(registry, chat.stop)
+
+      const thread = registry.get(chat.state)
+      const assistant = thread.messages[1]
+      expect(thread.active).toBeNull()
+      expect(assistant?.role === "assistant" && assistant.value.status).toBe("stopped")
+    }),
+  )
+
+  it.effect('busy "block" ignores input while a run is active', () =>
+    Effect.gen(function* () {
+      const chat = Atoms.thread({
+        runtime,
+        busy: "block",
+        transport: Transport.local((input: Input.Sent) =>
+          Stream.fromIterable(reply(input.id).slice(0, 2)).pipe(Stream.concat(Stream.never)),
+        ),
+      })
+      const registry = AtomRegistry.make()
+      registry.set(chat.submit, Input.submit("first"))
+      yield* streaming(registry, chat)
+      registry.set(chat.submit, Input.submit("second"))
+      yield* finished(registry, chat.submit)
+
+      const thread = registry.get(chat.state)
+      expect(
+        thread.messages.flatMap((m) => (m.role === "user" ? [Input.text(m.value)] : [])),
+      ).toEqual(["first"])
+      expect(thread.active?.status).toBe("streaming")
+    }),
+  )
+})
+
+// An in-memory session server: every run is appended to one replayed stream.
+const fakeSession = Effect.gen(function* () {
+  const chatId = StreamId.make("chat_1")
+  const events = yield* PubSub.unbounded<Envelope>({ replay: 1_000 })
+  const last = yield* Ref.make(0)
+  const transport = Transport.session({
+    send: (_: Option.Option<StreamId>, input: Input.Sent) =>
+      Ref.get(last).pipe(
+        Effect.flatMap((from) =>
+          Stream.fromIterable(reply(input.id)).pipe(
+            Run.sequence(chatId, { from }),
+            Stream.runForEach((envelope) =>
+              PubSub.publish(events, envelope).pipe(Effect.andThen(Ref.set(last, envelope.seq))),
+            ),
+          ),
+        ),
+        Effect.as(chatId),
+      ),
+    events: (_, after) => Stream.fromPubSub(events).pipe(Stream.filter((e) => e.seq > after)),
+  })
+  return { chatId, transport }
+})
+
+const settledCount = (
+  registry: AtomRegistry.AtomRegistry,
+  state: Atom.Atom<Thread.Thread>,
+  count: number,
+) =>
+  AtomRegistry.toStream(registry, state).pipe(
+    Stream.filter((t) => t.active === null && t.messages.length === count),
+    Stream.runHead,
+    Effect.map(Option.getOrThrow),
+  )
+
+describe("Atoms.sessionThread", () => {
+  it.effect("runs of one session land in one thread, and a new client re-opens all of them", () =>
+    Effect.gen(function* () {
+      const { chatId, transport } = yield* fakeSession
+      const chat = Atoms.sessionThread({ runtime, transport })
+      const registry = AtomRegistry.make()
+
+      registry.set(chat.submit, Input.submit("first"))
+      yield* settledCount(registry, chat.state, 2)
+      registry.set(chat.submit, Input.submit("second"))
+      const thread = yield* settledCount(registry, chat.state, 4)
+      expect(thread.messages.map((m) => m.role)).toEqual(["user", "assistant", "user", "assistant"])
+      expect(registry.get(chat.streamId)).toBe(chatId)
+
+      // After a reload: the same session, replayed from the start.
+      const reloaded = Atoms.sessionThread({ runtime, transport })
+      const fresh = AtomRegistry.make()
+      fresh.set(reloaded.open, chatId)
+      const replayed = yield* settledCount(fresh, reloaded.state, 2)
+      expect(replayed.messages.map((m) => m.role)).toEqual(["assistant", "assistant"])
+    }),
+  )
+})