@effect-uai/ui 0.0.0-stage → 0.17.0

package/dist/RunEvent.d.mts.map

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

package/dist/RunEvent.mjs

@@ -0,0 +1,264 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Schema } from "effect";
+import * as Items from "@effect-uai/core/Items";
+import * as Img from "@effect-uai/core/Image";
+//#region src/RunEvent.ts
+/**
+* The `@effect-uai/ui` wire protocol (v1): what a server streams to a client
+* about agent runs. Every frame is an `Envelope`; `seq` is per stream,
+* starts at 1 and never repeats, so clients dedupe and resume by it.
+*
+* A run starts with `run-started` and ends with exactly one terminal
+* (`run-completed`, `run-interrupted`, `run-failed`, `run-stopped`). Field
+* names are camelCase; the event discriminator is `type`.
+*/
+var RunEvent_exports = /* @__PURE__ */ __exportAll({
+	Citation: () => Citation,
+	Data: () => Data,
+	Envelope: () => Envelope,
+	EnvelopeJson: () => EnvelopeJson,
+	Image: () => Image,
+	InputAccepted: () => InputAccepted,
+	InputId: () => InputId,
+	Interrupt: () => Interrupt,
+	Live: () => Live,
+	ObjectDelta: () => ObjectDelta,
+	ObjectDone: () => ObjectDone,
+	ObjectFailed: () => ObjectFailed,
+	ObjectStarted: () => ObjectStarted,
+	Outcome: () => Outcome,
+	PROTOCOL_VERSION: () => 2,
+	ReasoningDelta: () => ReasoningDelta,
+	ReasoningStarted: () => ReasoningStarted,
+	RefusalDelta: () => RefusalDelta,
+	RunCompleted: () => RunCompleted,
+	RunEvent: () => RunEvent,
+	RunFailed: () => RunFailed,
+	RunId: () => RunId,
+	RunInterrupted: () => RunInterrupted,
+	RunStarted: () => RunStarted,
+	RunStopped: () => RunStopped,
+	StepFinished: () => StepFinished,
+	StepReset: () => StepReset,
+	StepStarted: () => StepStarted,
+	StreamId: () => StreamId,
+	TextDelta: () => TextDelta,
+	ToolApprovalRequested: () => ToolApprovalRequested,
+	ToolCallArgsDelta: () => ToolCallArgsDelta,
+	ToolCallReady: () => ToolCallReady,
+	ToolCallStarted: () => ToolCallStarted,
+	ToolPartial: () => ToolPartial,
+	ToolResult: () => ToolResult,
+	Usage: () => Usage,
+	envelopeFields: () => envelopeFields,
+	isTerminal: () => isTerminal,
+	outcome: () => outcome,
+	payloadEvents: () => payloadEvents,
+	plainEvents: () => plainEvents
+});
+const PROTOCOL_VERSION = 2;
+const StreamId = Schema.String.pipe(Schema.brand("StreamId"));
+const RunId = Schema.String.pipe(Schema.brand("RunId"));
+/** Client-generated id of one input. */
+const InputId = Schema.String.pipe(Schema.brand("InputId"));
+const event = (type, fields) => Schema.Struct({
+	type: Schema.Literal(type),
+	...fields
+});
+const RunStarted = event("run-started", {
+	runId: RunId,
+	/** Role of the run when a stream carries several, e.g. "assistant", "reviewer". */
+	name: Schema.optional(Schema.String),
+	/** Client input ids this run consumed, for optimistic-UI reconciliation. */
+	inputs: Schema.Array(InputId),
+	protocol: Schema.Literal(2)
+});
+/** A pause point the client must answer (today: a tool call awaiting approval). */
+const Interrupt = Schema.Struct({
+	callId: Schema.String,
+	reason: Schema.Literal("approval"),
+	name: Schema.String,
+	input: Schema.Json
+});
+const RunCompleted = event("run-completed", { metadata: Schema.optional(Schema.Json) });
+const RunInterrupted = event("run-interrupted", { interrupts: Schema.Array(Interrupt) });
+/** `reason` is a short code (an error's `_tag`); whether to offer a retry is the client's call. */
+const RunFailed = event("run-failed", {
+	reason: Schema.String,
+	message: Schema.optional(Schema.String)
+});
+const RunStopped = event("run-stopped", {});
+const StepStarted = event("step-started", {});
+const StepFinished = event("step-finished", { usage: Schema.optional(Items.Usage) });
+/** Discard the current step's partial output (mid-stream fallback or retry). */
+const StepReset = event("step-reset", {});
+const TextDelta = event("text-delta", { text: Schema.String });
+/** The model declined to answer; distinct from text (core's `refusal` block). */
+const RefusalDelta = event("refusal-delta", { text: Schema.String });
+const ReasoningStarted = event("reasoning-started", {});
+const ReasoningDelta = event("reasoning-delta", {
+	text: Schema.String,
+	kind: Schema.Literals(["trace", "summary"])
+});
+const Citation = event("citation", { annotation: Items.Annotation });
+const Image = event("image", {
+	image: Img.ImageSource,
+	/** Set only on a preview frame; absent means final. */
+	partialIndex: Schema.optional(Schema.Number)
+});
+const JsonPatchOperation = Schema.Union([
+	Schema.Struct({
+		op: Schema.Literal("add"),
+		path: Schema.String,
+		value: Schema.Json
+	}),
+	Schema.Struct({
+		op: Schema.Literal("remove"),
+		path: Schema.String
+	}),
+	Schema.Struct({
+		op: Schema.Literal("replace"),
+		path: Schema.String,
+		value: Schema.Json
+	})
+]);
+const ObjectStarted = event("object-started", {
+	id: Schema.String,
+	/** Which schema or list the object belongs to. */
+	name: Schema.optional(Schema.String)
+});
+/** Either a JSON Patch against the previous partial value, or a snapshot `value`. */
+const ObjectDelta = event("object-delta", {
+	id: Schema.String,
+	patch: Schema.optional(Schema.Array(JsonPatchOperation)),
+	value: Schema.optional(Schema.Json)
+});
+const ObjectDone = event("object-done", {
+	id: Schema.String,
+	/** The object's name again, so a client can decode `value` without state. */
+	name: Schema.optional(Schema.String),
+	value: Schema.Json
+});
+const ObjectFailed = event("object-failed", {
+	id: Schema.String,
+	issues: Schema.Array(Schema.Struct({
+		path: Schema.Array(Schema.Union([Schema.String, Schema.Number])),
+		message: Schema.String
+	}))
+});
+const ToolCallStarted = event("tool-call-started", {
+	callId: Schema.String,
+	name: Schema.String
+});
+const ToolCallArgsDelta = event("tool-call-args-delta", {
+	callId: Schema.String,
+	delta: Schema.String
+});
+const ToolCallReady = event("tool-call-ready", {
+	callId: Schema.String,
+	name: Schema.String,
+	input: Schema.Json
+});
+/** The run is waiting in-process for a decision on this call (it keeps running). */
+const ToolApprovalRequested = event("tool-approval-requested", {
+	callId: Schema.String,
+	name: Schema.String,
+	input: Schema.Json
+});
+/** An intermediate value of a streaming tool, encoded like its output. */
+const ToolPartial = event("tool-partial", {
+	callId: Schema.String,
+	name: Schema.String,
+	value: Schema.Json
+});
+/** How a call ended: its output, or an error (the tool's, core's, or the app's). */
+const outcome = (value, error) => Schema.Union([Schema.TaggedStruct("Success", { value }), Schema.TaggedStruct("Failure", { error })]);
+/** An outcome as sent: value and error are JSON. */
+const Outcome = outcome(Schema.Json, Schema.Json);
+/**
+* Every call ends with one `tool-result`: calls that ran, and calls the app
+* closed itself (denied, cancelled, answered by the user).
+*/
+const ToolResult = event("tool-result", {
+	callId: Schema.String,
+	/** The tool's name, so a client can decode `result` without state. */
+	name: Schema.String,
+	result: Outcome
+});
+const Usage = event("usage", { usage: Items.Usage });
+/** Persisted app payload; a repeated `id` replaces the earlier one in place. */
+const Data = event("data", {
+	name: Schema.String,
+	value: Schema.Json,
+	id: Schema.optional(Schema.String)
+});
+/** Transient app payload (metrics, status); latest value wins, never stored in a message. */
+const Live = event("live", {
+	name: Schema.String,
+	value: Schema.Json
+});
+/**
+* Stream-scoped: the server accepted an input (queued or about to run). Lets a
+* reloaded client show inputs that wait for their run. `input` is the app's
+* encoded input (e.g. `Input.InputJson`); its run's `run-started` lists its id.
+*/
+const InputAccepted = event("input-accepted", { input: Schema.Json });
+/** Events whose payloads a contract types (see `UiContract`). */
+const payloadEvents = [
+	RunCompleted,
+	RunInterrupted,
+	ObjectDone,
+	ToolCallReady,
+	ToolApprovalRequested,
+	ToolPartial,
+	ToolResult,
+	Data,
+	Live
+];
+/** Events a contract leaves as they are. */
+const plainEvents = [
+	RunStarted,
+	RunFailed,
+	RunStopped,
+	StepStarted,
+	StepFinished,
+	StepReset,
+	TextDelta,
+	RefusalDelta,
+	ReasoningStarted,
+	ReasoningDelta,
+	Citation,
+	Image,
+	ObjectStarted,
+	ObjectDelta,
+	ObjectFailed,
+	ToolCallStarted,
+	ToolCallArgsDelta,
+	Usage,
+	InputAccepted
+];
+/** The protocol as sent: payloads are JSON. A contract decodes them (`UiContract`). */
+const RunEvent = Schema.Union([...plainEvents, ...payloadEvents]);
+const envelopeFields = {
+	streamId: StreamId,
+	seq: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+	/** Set on run-scoped events; absent on stream-scoped ones. */
+	runId: Schema.optional(RunId)
+};
+const Envelope = Schema.Struct({
+	...envelopeFields,
+	event: RunEvent
+});
+/** JSON codec for the wire: `Uint8Array` image bytes and other non-JSON values encode safely. */
+const EnvelopeJson = Schema.toCodecJson(Envelope);
+const terminalTypes = /* @__PURE__ */ new Set([
+	"run-completed",
+	"run-interrupted",
+	"run-failed",
+	"run-stopped"
+]);
+const isTerminal = (event) => terminalTypes.has(event.type);
+//#endregion
+export { Citation, Data, Envelope, EnvelopeJson, Image, InputAccepted, InputId, Interrupt, Live, ObjectDelta, ObjectDone, ObjectFailed, ObjectStarted, Outcome, PROTOCOL_VERSION, ReasoningDelta, ReasoningStarted, RefusalDelta, RunCompleted, RunEvent, RunFailed, RunId, RunInterrupted, RunStarted, RunStopped, StepFinished, StepReset, StepStarted, StreamId, TextDelta, ToolApprovalRequested, ToolCallArgsDelta, ToolCallReady, ToolCallStarted, ToolPartial, ToolResult, Usage, envelopeFields, isTerminal, outcome, payloadEvents, plainEvents, RunEvent_exports as t };
+
+//# sourceMappingURL=RunEvent.mjs.map

package/dist/RunEvent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunEvent.mjs","names":[],"sources":["../src/RunEvent.ts"],"sourcesContent":["/**\n * The `@effect-uai/ui` wire protocol (v1): what a server streams to a client\n * about agent runs. Every frame is an `Envelope`; `seq` is per stream,\n * starts at 1 and never repeats, so clients dedupe and resume by it.\n *\n * A run starts with `run-started` and ends with exactly one terminal\n * (`run-completed`, `run-interrupted`, `run-failed`, `run-stopped`). Field\n * names are camelCase; the event discriminator is `type`.\n */\nimport * as Img from \"@effect-uai/core/Image\"\nimport * as Items from \"@effect-uai/core/Items\"\nimport { Schema } from \"effect\"\n\nexport const PROTOCOL_VERSION = 2\n\n// ---------------------------------------------------------------------------\n// Ids: branded so a stream, run and input id can't be swapped. Wire decoding\n// brands them; build one by hand with `StreamId.make(\"st_1\")`.\n// ---------------------------------------------------------------------------\n\nexport const StreamId = Schema.String.pipe(Schema.brand(\"StreamId\"))\nexport type StreamId = typeof StreamId.Type\n\nexport const RunId = Schema.String.pipe(Schema.brand(\"RunId\"))\nexport type RunId = typeof RunId.Type\n\n/** Client-generated id of one input. */\nexport const InputId = Schema.String.pipe(Schema.brand(\"InputId\"))\nexport type InputId = typeof InputId.Type\n\nconst event = <const T extends string, const F extends Schema.Struct.Fields>(type: T, fields: F) =>\n  Schema.Struct({ type: Schema.Literal(type), ...fields })\n\n// ---------------------------------------------------------------------------\n// Run lifecycle\n// ---------------------------------------------------------------------------\n\nexport const RunStarted = event(\"run-started\", {\n  runId: RunId,\n  /** Role of the run when a stream carries several, e.g. \"assistant\", \"reviewer\". */\n  name: Schema.optional(Schema.String),\n  /** Client input ids this run consumed, for optimistic-UI reconciliation. */\n  inputs: Schema.Array(InputId),\n  protocol: Schema.Literal(PROTOCOL_VERSION),\n})\n\n/** A pause point the client must answer (today: a tool call awaiting approval). */\nexport const Interrupt = Schema.Struct({\n  callId: Schema.String,\n  reason: Schema.Literal(\"approval\"),\n  name: Schema.String,\n  input: Schema.Json,\n})\n\nexport const RunCompleted = event(\"run-completed\", { metadata: Schema.optional(Schema.Json) })\nexport const RunInterrupted = event(\"run-interrupted\", { interrupts: Schema.Array(Interrupt) })\n/** `reason` is a short code (an error's `_tag`); whether to offer a retry is the client's call. */\nexport const RunFailed = event(\"run-failed\", {\n  reason: Schema.String,\n  message: Schema.optional(Schema.String),\n})\nexport const RunStopped = event(\"run-stopped\", {})\n\n// ---------------------------------------------------------------------------\n// Steps (one per model turn) and content\n// ---------------------------------------------------------------------------\n\nexport const StepStarted = event(\"step-started\", {})\nexport const StepFinished = event(\"step-finished\", { usage: Schema.optional(Items.Usage) })\n/** Discard the current step's partial output (mid-stream fallback or retry). */\nexport const StepReset = event(\"step-reset\", {})\n\nexport const TextDelta = event(\"text-delta\", { text: Schema.String })\n/** The model declined to answer; distinct from text (core's `refusal` block). */\nexport const RefusalDelta = event(\"refusal-delta\", { text: Schema.String })\nexport const ReasoningStarted = event(\"reasoning-started\", {})\nexport const ReasoningDelta = event(\"reasoning-delta\", {\n  text: Schema.String,\n  kind: Schema.Literals([\"trace\", \"summary\"]),\n})\nexport const Citation = event(\"citation\", { annotation: Items.Annotation })\nexport const Image = event(\"image\", {\n  image: Img.ImageSource,\n  /** Set only on a preview frame; absent means final. */\n  partialIndex: Schema.optional(Schema.Number),\n})\n\n// ---------------------------------------------------------------------------\n// Structured objects\n// ---------------------------------------------------------------------------\n\nconst JsonPatchOperation = Schema.Union([\n  Schema.Struct({ op: Schema.Literal(\"add\"), path: Schema.String, value: Schema.Json }),\n  Schema.Struct({ op: Schema.Literal(\"remove\"), path: Schema.String }),\n  Schema.Struct({ op: Schema.Literal(\"replace\"), path: Schema.String, value: Schema.Json }),\n])\n\nexport const ObjectStarted = event(\"object-started\", {\n  id: Schema.String,\n  /** Which schema or list the object belongs to. */\n  name: Schema.optional(Schema.String),\n})\n/** Either a JSON Patch against the previous partial value, or a snapshot `value`. */\nexport const ObjectDelta = event(\"object-delta\", {\n  id: Schema.String,\n  patch: Schema.optional(Schema.Array(JsonPatchOperation)),\n  value: Schema.optional(Schema.Json),\n})\nexport const ObjectDone = event(\"object-done\", {\n  id: Schema.String,\n  /** The object's name again, so a client can decode `value` without state. */\n  name: Schema.optional(Schema.String),\n  value: Schema.Json,\n})\nexport const ObjectFailed = event(\"object-failed\", {\n  id: Schema.String,\n  issues: Schema.Array(\n    Schema.Struct({\n      path: Schema.Array(Schema.Union([Schema.String, Schema.Number])),\n      message: Schema.String,\n    }),\n  ),\n})\n\n// ---------------------------------------------------------------------------\n// Tools\n// ---------------------------------------------------------------------------\n\nexport const ToolCallStarted = event(\"tool-call-started\", {\n  callId: Schema.String,\n  name: Schema.String,\n})\nexport const ToolCallArgsDelta = event(\"tool-call-args-delta\", {\n  callId: Schema.String,\n  delta: Schema.String,\n})\nexport const ToolCallReady = event(\"tool-call-ready\", {\n  callId: Schema.String,\n  name: Schema.String,\n  input: Schema.Json,\n})\n/** The run is waiting in-process for a decision on this call (it keeps running). */\nexport const ToolApprovalRequested = event(\"tool-approval-requested\", {\n  callId: Schema.String,\n  name: Schema.String,\n  input: Schema.Json,\n})\n/** An intermediate value of a streaming tool, encoded like its output. */\nexport const ToolPartial = event(\"tool-partial\", {\n  callId: Schema.String,\n  name: Schema.String,\n  value: Schema.Json,\n})\n\n/** How a call ended: its output, or an error (the tool's, core's, or the app's). */\nexport const outcome = <V extends Schema.Top, E extends Schema.Top>(value: V, error: E) =>\n  Schema.Union([\n    Schema.TaggedStruct(\"Success\", { value }),\n    Schema.TaggedStruct(\"Failure\", { error }),\n  ])\n\n/** An outcome as sent: value and error are JSON. */\nexport const Outcome = outcome(Schema.Json, Schema.Json)\n\nexport type Outcome<V = Json, E = Json> =\n  | { readonly _tag: \"Success\"; readonly value: V }\n  | { readonly _tag: \"Failure\"; readonly error: E }\n\n/**\n * Every call ends with one `tool-result`: calls that ran, and calls the app\n * closed itself (denied, cancelled, answered by the user).\n */\nexport const ToolResult = event(\"tool-result\", {\n  callId: Schema.String,\n  /** The tool's name, so a client can decode `result` without state. */\n  name: Schema.String,\n  result: Outcome,\n})\n\n// ---------------------------------------------------------------------------\n// Usage and app payloads\n// ---------------------------------------------------------------------------\n\nexport const Usage = event(\"usage\", { usage: Items.Usage })\n/** Persisted app payload; a repeated `id` replaces the earlier one in place. */\nexport const Data = event(\"data\", {\n  name: Schema.String,\n  value: Schema.Json,\n  id: Schema.optional(Schema.String),\n})\n/** Transient app payload (metrics, status); latest value wins, never stored in a message. */\nexport const Live = event(\"live\", { name: Schema.String, value: Schema.Json })\n\n/**\n * Stream-scoped: the server accepted an input (queued or about to run). Lets a\n * reloaded client show inputs that wait for their run. `input` is the app's\n * encoded input (e.g. `Input.InputJson`); its run's `run-started` lists its id.\n */\nexport const InputAccepted = event(\"input-accepted\", { input: Schema.Json })\n\n// ---------------------------------------------------------------------------\n// Unions and envelope\n// ---------------------------------------------------------------------------\n\n/** Events whose payloads a contract types (see `UiContract`). */\nexport const payloadEvents = [\n  RunCompleted,\n  RunInterrupted,\n  ObjectDone,\n  ToolCallReady,\n  ToolApprovalRequested,\n  ToolPartial,\n  ToolResult,\n  Data,\n  Live,\n] as const\n\n/** Events a contract leaves as they are. */\nexport const plainEvents = [\n  RunStarted,\n  RunFailed,\n  RunStopped,\n  StepStarted,\n  StepFinished,\n  StepReset,\n  TextDelta,\n  RefusalDelta,\n  ReasoningStarted,\n  ReasoningDelta,\n  Citation,\n  Image,\n  ObjectStarted,\n  ObjectDelta,\n  ObjectFailed,\n  ToolCallStarted,\n  ToolCallArgsDelta,\n  Usage,\n  InputAccepted,\n] as const\n\n/** The protocol as sent: payloads are JSON. A contract decodes them (`UiContract`). */\nexport const RunEvent = Schema.Union([...plainEvents, ...payloadEvents])\n\nexport const envelopeFields = {\n  streamId: StreamId,\n  seq: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),\n  /** Set on run-scoped events; absent on stream-scoped ones. */\n  runId: Schema.optional(RunId),\n}\n\nexport const Envelope = Schema.Struct({ ...envelopeFields, event: RunEvent })\n\n/** JSON codec for the wire: `Uint8Array` image bytes and other non-JSON values encode safely. */\nexport const EnvelopeJson = Schema.toCodecJson(Envelope)\n\n// ---------------------------------------------------------------------------\n// Payload types: what a contract types. `P` defaults to `Untyped` (JSON as sent).\n// ---------------------------------------------------------------------------\n\nexport type Json = Schema.Json\n\nexport type ToolPayload = {\n  readonly name: string\n  readonly input: unknown\n  readonly output: unknown\n  /** Every error a call of this tool can end with. */\n  readonly failure: unknown\n}\nexport type NamedPayload = { readonly name: string; readonly value: unknown }\n\n/** Typed payloads: each field is a union with one member per name. */\nexport type Payloads = {\n  readonly tool: ToolPayload\n  readonly object: NamedPayload\n  readonly data: NamedPayload\n  readonly live: NamedPayload\n  readonly metadata: unknown\n}\n\n/** No contract: any name, payloads as sent. */\nexport type Untyped = {\n  readonly tool: {\n    readonly name: string\n    readonly input: Json\n    readonly output: Json\n    readonly failure: Json\n  }\n  readonly object: { readonly name: string; readonly value: Json }\n  readonly data: { readonly name: string; readonly value: Json }\n  readonly live: { readonly name: string; readonly value: Json }\n  readonly metadata: Json\n}\n\ntype Plain = (typeof plainEvents)[number][\"Type\"]\n\n// Distributes over the tool union, so narrowing by `name` types `value` and `result`.\ntype ToolEvents<T> = T extends ToolPayload\n  ?\n      | {\n          readonly type: \"tool-partial\"\n          readonly callId: string\n          readonly name: T[\"name\"]\n          readonly value: T[\"output\"]\n        }\n      | {\n          readonly type: \"tool-result\"\n          readonly callId: string\n          readonly name: T[\"name\"]\n          readonly result: Outcome<T[\"output\"], T[\"failure\"]>\n        }\n  : never\n\nexport type Interrupt<P extends Payloads = Untyped> = {\n  readonly callId: string\n  readonly reason: \"approval\"\n  readonly name: P[\"tool\"][\"name\"]\n  readonly input: P[\"tool\"][\"input\"]\n}\n\ntype Typed<P extends Payloads> =\n  | { readonly type: \"run-completed\"; readonly metadata?: P[\"metadata\"] | undefined }\n  | { readonly type: \"run-interrupted\"; readonly interrupts: ReadonlyArray<Interrupt<P>> }\n  | {\n      readonly type: \"object-done\"\n      readonly id: string\n      readonly name?: P[\"object\"][\"name\"] | undefined\n      readonly value: P[\"object\"][\"value\"]\n    }\n  | {\n      readonly type: \"tool-call-ready\"\n      readonly callId: string\n      readonly name: P[\"tool\"][\"name\"]\n      readonly input: P[\"tool\"][\"input\"]\n    }\n  | {\n      readonly type: \"tool-approval-requested\"\n      readonly callId: string\n      readonly name: P[\"tool\"][\"name\"]\n      readonly input: P[\"tool\"][\"input\"]\n    }\n  | ToolEvents<P[\"tool\"]>\n  | {\n      readonly type: \"data\"\n      readonly name: P[\"data\"][\"name\"]\n      readonly value: P[\"data\"][\"value\"]\n      readonly id?: string | undefined\n    }\n  | { readonly type: \"live\"; readonly name: P[\"live\"][\"name\"]; readonly value: P[\"live\"][\"value\"] }\n\n/** One event; with a contract's `P`, its payloads are decoded. */\nexport type RunEvent<P extends Payloads = Untyped> = Plain | Typed<P>\n\nexport type Envelope<P extends Payloads = Untyped> = {\n  readonly streamId: StreamId\n  readonly seq: number\n  readonly runId?: RunId | undefined\n  readonly event: RunEvent<P>\n}\n\nexport type Terminal<P extends Payloads = Untyped> = Extract<\n  RunEvent<P>,\n  { readonly type: \"run-completed\" | \"run-interrupted\" | \"run-failed\" | \"run-stopped\" }\n>\n\nconst terminalTypes: ReadonlySet<string> = new Set([\n  \"run-completed\",\n  \"run-interrupted\",\n  \"run-failed\",\n  \"run-stopped\",\n])\n\nexport const isTerminal = <P extends Payloads = Untyped>(\n  event: RunEvent<P>,\n): event is Terminal<P> => terminalTypes.has(event.type)\n"],"mappings":"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"}