@effect-uai/core 0.14.0 → 0.15.0

package/dist/messenger/Messenger.d.mts

@@ -0,0 +1,472 @@
+import { a as MediaSource } from "../Media-BbX7BAaO.mjs";
+import { n as MessengerError } from "../MessengerError-CeK6VAcu.mjs";
+import { Brand, Context, Data, Effect, Option, Scope, Stream } from "effect";
+declare namespace Messenger_d_exports {
+  export { ChannelId, ConversationRef, CurrentConversation, InboundEvent, MessageId, MessageRef, Messenger, MessengerLimits, MessengerService, Outbound, OutboundBody, OutboundOptions, StreamOptions, ThreadId, UserId, conversationKey, edit, events, inConversation, media, post, raw, react, stream, text, typing };
+}
+/** Where messages go. Providers mint these per their own scheme; core treats them opaquely. */
+type ChannelId = Brand.Branded<string, "ChannelId">;
+declare const ChannelId: Brand.Constructor<ChannelId>;
+/** One message inside a channel. Only a named message can be edited or reacted to. */
+type MessageId = Brand.Branded<string, "MessageId">;
+declare const MessageId: Brand.Constructor<MessageId>;
+/** The human (or bot) an event came from. */
+type UserId = Brand.Branded<string, "UserId">;
+declare const UserId: Brand.Constructor<UserId>;
+/** A sub-conversation inside a channel, where the platform has one. Opaque, provider-minted. */
+type ThreadId = Brand.Branded<string, "ThreadId">;
+declare const ThreadId: Brand.Constructor<ThreadId>;
+/**
+ * Where a conversation happens. `thread` is provider-interpreted: a Slack
+ * `thread_ts`, a Telegram forum topic, unset on Discord (where a thread is
+ * its own channel).
+ */
+type ConversationRef = {
+  readonly channel: ChannelId;
+  readonly thread?: ThreadId;
+};
+type MessageRef = {
+  readonly conversation: ConversationRef;
+  readonly id: MessageId;
+};
+/** Stable key for a conversation. Index per-conversation state with it. */
+declare const conversationKey: (ref: ConversationRef) => string;
+/**
+ * What the world says to the agent. `raw` is the untouched platform payload,
+ * for everything the shared shape drops.
+ *
+ * `addressed` is the rule recipes branch on: a DM, a mention of the bot, or
+ * a reply to one of its messages. Each adapter owns that decision (and hides
+ * Telegram privacy mode / Discord intents behind it), and delivers `text`
+ * with the bot's own mention stripped.
+ *
+ * `Reaction.emoji` is the platform's own spelling, the same one `react`
+ * accepts: unicode where the platform speaks unicode, a shortcode where it
+ * speaks shortcodes.
+ */
+type InboundEvent = Data.TaggedEnum<{
+  Message: {
+    readonly conversation: ConversationRef;
+    readonly id: MessageId;
+    readonly author: UserId;
+    readonly text: string;
+    readonly addressed: boolean;
+    readonly replyTo?: MessageId;
+    readonly raw: unknown;
+  };
+  Reaction: {
+    readonly conversation: ConversationRef;
+    readonly message: MessageId;
+    readonly emoji: string;
+    readonly author: UserId;
+    readonly raw: unknown;
+  };
+  Command: {
+    readonly conversation: ConversationRef;
+    readonly name: string;
+    readonly args: string;
+    readonly author: UserId;
+    readonly raw: unknown;
+  };
+  Action: {
+    readonly conversation: ConversationRef;
+    readonly actionId: string;
+    readonly value?: string;
+    readonly author: UserId;
+    readonly raw: unknown;
+  };
+}>;
+declare const InboundEvent: {
+  readonly $is: <Tag extends "Action" | "Command" | "Message" | "Reaction">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Action";
+    readonly conversation: ConversationRef;
+    readonly actionId: string;
+    readonly value?: string;
+    readonly author: UserId;
+    readonly raw: unknown;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Command";
+    readonly conversation: ConversationRef;
+    readonly name: string;
+    readonly args: string;
+    readonly author: UserId;
+    readonly raw: unknown;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Message";
+    readonly conversation: ConversationRef;
+    readonly id: MessageId;
+    readonly author: UserId;
+    readonly text: string;
+    readonly addressed: boolean;
+    readonly replyTo?: MessageId;
+    readonly raw: unknown;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Reaction";
+    readonly conversation: ConversationRef;
+    readonly message: MessageId;
+    readonly emoji: string;
+    readonly author: UserId;
+    readonly raw: unknown;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Action" | "Command" | "Message" | "Reaction"]: (args: Extract<{
+      readonly _tag: "Action";
+      readonly conversation: ConversationRef;
+      readonly actionId: string;
+      readonly value?: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Command";
+      readonly conversation: ConversationRef;
+      readonly name: string;
+      readonly args: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Message";
+      readonly conversation: ConversationRef;
+      readonly id: MessageId;
+      readonly author: UserId;
+      readonly text: string;
+      readonly addressed: boolean;
+      readonly replyTo?: MessageId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Reaction";
+      readonly conversation: ConversationRef;
+      readonly message: MessageId;
+      readonly emoji: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Action";
+      readonly conversation: ConversationRef;
+      readonly actionId: string;
+      readonly value?: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Command";
+      readonly conversation: ConversationRef;
+      readonly name: string;
+      readonly args: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Message";
+      readonly conversation: ConversationRef;
+      readonly id: MessageId;
+      readonly author: UserId;
+      readonly text: string;
+      readonly addressed: boolean;
+      readonly replyTo?: MessageId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Reaction";
+      readonly conversation: ConversationRef;
+      readonly message: MessageId;
+      readonly emoji: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Action" | "Command" | "Message" | "Reaction"]>>;
+    <Cases extends { readonly [Tag in "Action" | "Command" | "Message" | "Reaction"]: (args: Extract<{
+      readonly _tag: "Action";
+      readonly conversation: ConversationRef;
+      readonly actionId: string;
+      readonly value?: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Command";
+      readonly conversation: ConversationRef;
+      readonly name: string;
+      readonly args: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Message";
+      readonly conversation: ConversationRef;
+      readonly id: MessageId;
+      readonly author: UserId;
+      readonly text: string;
+      readonly addressed: boolean;
+      readonly replyTo?: MessageId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Reaction";
+      readonly conversation: ConversationRef;
+      readonly message: MessageId;
+      readonly emoji: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Action";
+      readonly conversation: ConversationRef;
+      readonly actionId: string;
+      readonly value?: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Command";
+      readonly conversation: ConversationRef;
+      readonly name: string;
+      readonly args: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Message";
+      readonly conversation: ConversationRef;
+      readonly id: MessageId;
+      readonly author: UserId;
+      readonly text: string;
+      readonly addressed: boolean;
+      readonly replyTo?: MessageId;
+      readonly raw: unknown;
+    } | {
+      readonly _tag: "Reaction";
+      readonly conversation: ConversationRef;
+      readonly message: MessageId;
+      readonly emoji: string;
+      readonly author: UserId;
+      readonly raw: unknown;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Action" | "Command" | "Message" | "Reaction"]>>;
+  };
+  readonly Action: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Action";
+    readonly conversation: ConversationRef;
+    readonly actionId: string;
+    readonly value?: string;
+    readonly author: UserId;
+    readonly raw: unknown;
+  }, "_tag">;
+  readonly Command: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Command";
+    readonly conversation: ConversationRef;
+    readonly name: string;
+    readonly args: string;
+    readonly author: UserId;
+    readonly raw: unknown;
+  }, "_tag">;
+  readonly Message: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Message";
+    readonly conversation: ConversationRef;
+    readonly id: MessageId;
+    readonly author: UserId;
+    readonly text: string;
+    readonly addressed: boolean;
+    readonly replyTo?: MessageId;
+    readonly raw: unknown;
+  }, "_tag">;
+  readonly Reaction: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Reaction";
+    readonly conversation: ConversationRef;
+    readonly message: MessageId;
+    readonly emoji: string;
+    readonly author: UserId;
+    readonly raw: unknown;
+  }, "_tag">;
+};
+/**
+ * What the agent says. `Text` is sent verbatim: each provider layer says
+ * which markup it expects (Telegram HTML, Slack markdown), and the prompt is
+ * where that gets decided. Nothing here converts. `Media` reuses the core
+ * {@link MediaSource}, so a URL, base64 or raw bytes all work; the adapter
+ * routes on `mimeType` (`image/*` to a photo endpoint, `audio/*` to an audio
+ * one, everything else to a file upload), which is why a URL source without
+ * a `mimeType` goes as a plain file. `Raw` bypasses the shape entirely and
+ * reaches the platform as-is: the escape hatch for buttons, cards and
+ * everything the verbs do not unify.
+ */
+type OutboundBody = Data.TaggedEnum<{
+  Text: {
+    readonly text: string;
+  };
+  Media: {
+    readonly media: MediaSource;
+    readonly caption?: string;
+    readonly filename?: string;
+  };
+  Raw: {
+    readonly payload: unknown;
+  };
+}>;
+declare const OutboundBody: {
+  readonly $is: <Tag extends "Media" | "Raw" | "Text">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Media";
+    readonly media: MediaSource;
+    readonly caption?: string;
+    readonly filename?: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Raw";
+    readonly payload: unknown;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Text";
+    readonly text: string;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Media" | "Raw" | "Text"]: (args: Extract<{
+      readonly _tag: "Media";
+      readonly media: MediaSource;
+      readonly caption?: string;
+      readonly filename?: string;
+    } | {
+      readonly _tag: "Raw";
+      readonly payload: unknown;
+    } | {
+      readonly _tag: "Text";
+      readonly text: string;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Media";
+      readonly media: MediaSource;
+      readonly caption?: string;
+      readonly filename?: string;
+    } | {
+      readonly _tag: "Raw";
+      readonly payload: unknown;
+    } | {
+      readonly _tag: "Text";
+      readonly text: string;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Media" | "Raw" | "Text"]>>;
+    <Cases extends { readonly [Tag in "Media" | "Raw" | "Text"]: (args: Extract<{
+      readonly _tag: "Media";
+      readonly media: MediaSource;
+      readonly caption?: string;
+      readonly filename?: string;
+    } | {
+      readonly _tag: "Raw";
+      readonly payload: unknown;
+    } | {
+      readonly _tag: "Text";
+      readonly text: string;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Media";
+      readonly media: MediaSource;
+      readonly caption?: string;
+      readonly filename?: string;
+    } | {
+      readonly _tag: "Raw";
+      readonly payload: unknown;
+    } | {
+      readonly _tag: "Text";
+      readonly text: string;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Media" | "Raw" | "Text"]>>;
+  };
+  readonly Media: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Media";
+    readonly media: MediaSource;
+    readonly caption?: string;
+    readonly filename?: string;
+  }, "_tag">;
+  readonly Raw: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Raw";
+    readonly payload: unknown;
+  }, "_tag">;
+  readonly Text: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Text";
+    readonly text: string;
+  }, "_tag">;
+};
+/**
+ * A body plus the envelope fields true of any message. `replyTo` is ignored
+ * for a `Raw` body, which names its own wire fields.
+ */
+type Outbound = {
+  readonly body: OutboundBody;
+  readonly replyTo?: MessageId;
+};
+type OutboundOptions = {
+  readonly replyTo?: MessageId;
+};
+/** Text message. The overwhelmingly common case: `post(text("hi"))`. */
+declare const text: (body: string, options?: OutboundOptions) => Outbound;
+/** Media message. `caption` and `filename` describe the media, not the envelope. */
+declare const media: (source: MediaSource, options?: OutboundOptions & {
+  readonly caption?: string;
+  readonly filename?: string;
+}) => Outbound;
+/** Platform payload, passed through untouched. */
+declare const raw: (payload: unknown) => Outbound;
+declare const CurrentConversation_base: Context.ServiceClass<CurrentConversation, "@betalyra/effect-uai/Messenger/CurrentConversation", ConversationRef>;
+/**
+ * The conversation the outbound verbs target. A tag with no default, so
+ * posting outside an established conversation is a compile error. Deep code
+ * (a tool posting progress, an approval resolver) inherits it rather than
+ * threading a ref down.
+ */
+declare class CurrentConversation extends CurrentConversation_base {}
+/** Run `effect` against `ref`. Wrap a conversation fiber once; every nested post lands. */
+declare const inConversation: (ref: ConversationRef) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, CurrentConversation>>;
+/** Envelope of a streamed reply. `replyTo` lands on the first message it posts. */
+type StreamOptions = OutboundOptions;
+/** Platform ceilings, so recipes can see them before composing a message. */
+type MessengerLimits = {
+  /** Longest single text message. */
+  readonly maxText: number;
+  /** Longest caption on a media message. */
+  readonly maxCaption: number;
+};
+/**
+ * Cross-platform messaging: one inbound stream, five outbound verbs.
+ *
+ * `events` is single-consumer and provider-owned. The connection opens when
+ * the layer is built and closes with its scope, so there is no connect /
+ * disconnect here, and reconnects, acks and callback answering all happen
+ * below this line.
+ *
+ * `post`, `typing` and `stream` target the ambient
+ * {@link CurrentConversation}; `edit` and `react` name a message outright.
+ */
+type MessengerService = {
+  readonly events: Stream.Stream<InboundEvent, MessengerError>;
+  /** Text past `limits.maxText` goes out as several messages; the id is the last. */
+  readonly post: (msg: Outbound) => Effect.Effect<MessageId, MessengerError, CurrentConversation>;
+  readonly edit: (msg: MessageRef, next: Outbound) => Effect.Effect<void, MessengerError>;
+  /**
+   * `emoji` in the platform's own spelling, as its `Reaction` events deliver
+   * it. Nothing is translated; one the platform rejects fails
+   * `MessengerUnsupported`.
+   */
+  readonly react: (msg: MessageRef, emoji: string) => Effect.Effect<void, MessengerError>;
+  /** Activity indicator, kept alive by the adapter until the scope closes. */
+  readonly typing: Effect.Effect<void, MessengerError, CurrentConversation | Scope.Scope>;
+  /**
+   * Progressive delivery of a text stream; the mechanism is the adapter's.
+   * The id is the last message posted, `None` when the stream had no text.
+   */
+  readonly stream: <E, R>(deltas: Stream.Stream<string, E, R>, options?: StreamOptions) => Effect.Effect<Option.Option<MessageId>, MessengerError | E, R | CurrentConversation>;
+  readonly limits: MessengerLimits;
+};
+declare const Messenger_base: Context.ServiceClass<Messenger, "@betalyra/effect-uai/Messenger", MessengerService>;
+declare class Messenger extends Messenger_base {}
+declare const events: Stream.Stream<InboundEvent, MessengerError, Messenger>;
+declare const post: (msg: Outbound) => Effect.Effect<MessageId, MessengerError, Messenger | CurrentConversation>;
+declare const edit: (msg: MessageRef, next: Outbound) => Effect.Effect<void, MessengerError, Messenger>;
+declare const react: (msg: MessageRef, emoji: string) => Effect.Effect<void, MessengerError, Messenger>;
+declare const typing: Effect.Effect<void, MessengerError, Messenger | CurrentConversation | Scope.Scope>;
+declare const stream: <E, R>(deltas: Stream.Stream<string, E, R>, options?: StreamOptions) => Effect.Effect<Option.Option<MessageId>, MessengerError | E, R | Messenger | CurrentConversation>;
+//#endregion
+export { ChannelId, ConversationRef, CurrentConversation, InboundEvent, MessageId, MessageRef, Messenger, MessengerLimits, MessengerService, Outbound, OutboundBody, OutboundOptions, StreamOptions, ThreadId, UserId, conversationKey, edit, events, inConversation, media, post, raw, react, stream, Messenger_d_exports as t, text, typing };
+//# sourceMappingURL=Messenger.d.mts.map

package/dist/messenger/Messenger.d.mts.map

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

package/dist/messenger/Messenger.mjs

@@ -0,0 +1,66 @@
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
+import { Brand, Context, Data, Effect, Stream } from "effect";
+//#region src/messenger/Messenger.ts
+var Messenger_exports = /* @__PURE__ */ __exportAll({
+	ChannelId: () => ChannelId,
+	CurrentConversation: () => CurrentConversation,
+	InboundEvent: () => InboundEvent,
+	MessageId: () => MessageId,
+	Messenger: () => Messenger,
+	OutboundBody: () => OutboundBody,
+	ThreadId: () => ThreadId,
+	UserId: () => UserId,
+	conversationKey: () => conversationKey,
+	edit: () => edit,
+	events: () => events,
+	inConversation: () => inConversation,
+	media: () => media,
+	post: () => post,
+	raw: () => raw,
+	react: () => react,
+	stream: () => stream,
+	text: () => text,
+	typing: () => typing
+});
+const ChannelId = Brand.nominal();
+const MessageId = Brand.nominal();
+const UserId = Brand.nominal();
+const ThreadId = Brand.nominal();
+/** Stable key for a conversation. Index per-conversation state with it. */
+const conversationKey = (ref) => ref.thread === void 0 ? ref.channel : `${ref.channel}/${ref.thread}`;
+const InboundEvent = Data.taggedEnum();
+const OutboundBody = Data.taggedEnum();
+const envelope = (body, options) => ({
+	body,
+	...options?.replyTo !== void 0 && { replyTo: options.replyTo }
+});
+/** Text message. The overwhelmingly common case: `post(text("hi"))`. */
+const text = (body, options) => envelope(OutboundBody.Text({ text: body }), options);
+/** Media message. `caption` and `filename` describe the media, not the envelope. */
+const media = (source, options) => envelope(OutboundBody.Media({
+	media: source,
+	...options?.caption !== void 0 && { caption: options.caption },
+	...options?.filename !== void 0 && { filename: options.filename }
+}), options);
+/** Platform payload, passed through untouched. */
+const raw = (payload) => ({ body: OutboundBody.Raw({ payload }) });
+/**
+* The conversation the outbound verbs target. A tag with no default, so
+* posting outside an established conversation is a compile error. Deep code
+* (a tool posting progress, an approval resolver) inherits it rather than
+* threading a ref down.
+*/
+var CurrentConversation = class extends Context.Service()("@betalyra/effect-uai/Messenger/CurrentConversation") {};
+/** Run `effect` against `ref`. Wrap a conversation fiber once; every nested post lands. */
+const inConversation = (ref) => (effect) => Effect.provideService(effect, CurrentConversation, ref);
+var Messenger = class extends Context.Service()("@betalyra/effect-uai/Messenger") {};
+const events = Stream.unwrap(Effect.map(Messenger, (m) => m.events));
+const post = (msg) => Effect.flatMap(Messenger, (m) => m.post(msg));
+const edit = (msg, next) => Effect.flatMap(Messenger, (m) => m.edit(msg, next));
+const react = (msg, emoji) => Effect.flatMap(Messenger, (m) => m.react(msg, emoji));
+const typing = Effect.flatMap(Messenger, (m) => m.typing);
+const stream = (deltas, options) => Effect.flatMap(Messenger, (m) => m.stream(deltas, options));
+//#endregion
+export { ChannelId, CurrentConversation, InboundEvent, MessageId, Messenger, OutboundBody, ThreadId, UserId, conversationKey, edit, events, inConversation, media, post, raw, react, stream, Messenger_exports as t, text, typing };
+
+//# sourceMappingURL=Messenger.mjs.map

package/dist/messenger/Messenger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Messenger.mjs","names":[],"sources":["../../src/messenger/Messenger.ts"],"sourcesContent":["import { Brand, Context, Data, Effect, type Option, type Scope, Stream } from \"effect\"\nimport type { MediaSource } from \"../domain/Media.js\"\nimport type * as MessengerError from \"./MessengerError.js\"\n\n// ---------------------------------------------------------------------------\n// Identity\n// ---------------------------------------------------------------------------\n\n/** Where messages go. Providers mint these per their own scheme; core treats them opaquely. */\nexport type ChannelId = Brand.Branded<string, \"ChannelId\">\nexport const ChannelId = Brand.nominal<ChannelId>()\n\n/** One message inside a channel. Only a named message can be edited or reacted to. */\nexport type MessageId = Brand.Branded<string, \"MessageId\">\nexport const MessageId = Brand.nominal<MessageId>()\n\n/** The human (or bot) an event came from. */\nexport type UserId = Brand.Branded<string, \"UserId\">\nexport const UserId = Brand.nominal<UserId>()\n\n/** A sub-conversation inside a channel, where the platform has one. Opaque, provider-minted. */\nexport type ThreadId = Brand.Branded<string, \"ThreadId\">\nexport const ThreadId = Brand.nominal<ThreadId>()\n\n/**\n * Where a conversation happens. `thread` is provider-interpreted: a Slack\n * `thread_ts`, a Telegram forum topic, unset on Discord (where a thread is\n * its own channel).\n */\nexport type ConversationRef = {\n  readonly channel: ChannelId\n  readonly thread?: ThreadId\n}\n\nexport type MessageRef = {\n  readonly conversation: ConversationRef\n  readonly id: MessageId\n}\n\n/** Stable key for a conversation. Index per-conversation state with it. */\nexport const conversationKey = (ref: ConversationRef): string =>\n  ref.thread === undefined ? ref.channel : `${ref.channel}/${ref.thread}`\n\n// ---------------------------------------------------------------------------\n// Inbound\n// ---------------------------------------------------------------------------\n\n/**\n * What the world says to the agent. `raw` is the untouched platform payload,\n * for everything the shared shape drops.\n *\n * `addressed` is the rule recipes branch on: a DM, a mention of the bot, or\n * a reply to one of its messages. Each adapter owns that decision (and hides\n * Telegram privacy mode / Discord intents behind it), and delivers `text`\n * with the bot's own mention stripped.\n *\n * `Reaction.emoji` is the platform's own spelling, the same one `react`\n * accepts: unicode where the platform speaks unicode, a shortcode where it\n * speaks shortcodes.\n */\nexport type InboundEvent = Data.TaggedEnum<{\n  Message: {\n    readonly conversation: ConversationRef\n    readonly id: MessageId\n    readonly author: UserId\n    readonly text: string\n    readonly addressed: boolean\n    readonly replyTo?: MessageId\n    readonly raw: unknown\n  }\n  Reaction: {\n    readonly conversation: ConversationRef\n    readonly message: MessageId\n    readonly emoji: string\n    readonly author: UserId\n    readonly raw: unknown\n  }\n  Command: {\n    readonly conversation: ConversationRef\n    readonly name: string\n    readonly args: string\n    readonly author: UserId\n    readonly raw: unknown\n  }\n  Action: {\n    readonly conversation: ConversationRef\n    readonly actionId: string\n    readonly value?: string\n    readonly author: UserId\n    readonly raw: unknown\n  }\n}>\n\nexport const InboundEvent = Data.taggedEnum<InboundEvent>()\n\n// ---------------------------------------------------------------------------\n// Outbound\n// ---------------------------------------------------------------------------\n\n/**\n * What the agent says. `Text` is sent verbatim: each provider layer says\n * which markup it expects (Telegram HTML, Slack markdown), and the prompt is\n * where that gets decided. Nothing here converts. `Media` reuses the core\n * {@link MediaSource}, so a URL, base64 or raw bytes all work; the adapter\n * routes on `mimeType` (`image/*` to a photo endpoint, `audio/*` to an audio\n * one, everything else to a file upload), which is why a URL source without\n * a `mimeType` goes as a plain file. `Raw` bypasses the shape entirely and\n * reaches the platform as-is: the escape hatch for buttons, cards and\n * everything the verbs do not unify.\n */\nexport type OutboundBody = Data.TaggedEnum<{\n  Text: { readonly text: string }\n  Media: {\n    readonly media: MediaSource\n    readonly caption?: string\n    readonly filename?: string\n  }\n  Raw: { readonly payload: unknown }\n}>\n\nexport const OutboundBody = Data.taggedEnum<OutboundBody>()\n\n/**\n * A body plus the envelope fields true of any message. `replyTo` is ignored\n * for a `Raw` body, which names its own wire fields.\n */\nexport type Outbound = {\n  readonly body: OutboundBody\n  readonly replyTo?: MessageId\n}\n\nexport type OutboundOptions = { readonly replyTo?: MessageId }\n\nconst envelope = (body: OutboundBody, options?: OutboundOptions): Outbound => ({\n  body,\n  ...(options?.replyTo !== undefined && { replyTo: options.replyTo }),\n})\n\n/** Text message. The overwhelmingly common case: `post(text(\"hi\"))`. */\nexport const text = (body: string, options?: OutboundOptions): Outbound =>\n  envelope(OutboundBody.Text({ text: body }), options)\n\n/** Media message. `caption` and `filename` describe the media, not the envelope. */\nexport const media = (\n  source: MediaSource,\n  options?: OutboundOptions & { readonly caption?: string; readonly filename?: string },\n): Outbound =>\n  envelope(\n    OutboundBody.Media({\n      media: source,\n      ...(options?.caption !== undefined && { caption: options.caption }),\n      ...(options?.filename !== undefined && { filename: options.filename }),\n    }),\n    options,\n  )\n\n/** Platform payload, passed through untouched. */\nexport const raw = (payload: unknown): Outbound => ({ body: OutboundBody.Raw({ payload }) })\n\n// ---------------------------------------------------------------------------\n// Ambient conversation targeting\n// ---------------------------------------------------------------------------\n\n/**\n * The conversation the outbound verbs target. A tag with no default, so\n * posting outside an established conversation is a compile error. Deep code\n * (a tool posting progress, an approval resolver) inherits it rather than\n * threading a ref down.\n */\nexport class CurrentConversation extends Context.Service<CurrentConversation, ConversationRef>()(\n  \"@betalyra/effect-uai/Messenger/CurrentConversation\",\n) {}\n\n/** Run `effect` against `ref`. Wrap a conversation fiber once; every nested post lands. */\nexport const inConversation =\n  (ref: ConversationRef) =>\n  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, Exclude<R, CurrentConversation>> =>\n    Effect.provideService(effect, CurrentConversation, ref)\n\n// ---------------------------------------------------------------------------\n// Service definition\n// ---------------------------------------------------------------------------\n\n/** Envelope of a streamed reply. `replyTo` lands on the first message it posts. */\nexport type StreamOptions = OutboundOptions\n\n/** Platform ceilings, so recipes can see them before composing a message. */\nexport type MessengerLimits = {\n  /** Longest single text message. */\n  readonly maxText: number\n  /** Longest caption on a media message. */\n  readonly maxCaption: number\n}\n\n/**\n * Cross-platform messaging: one inbound stream, five outbound verbs.\n *\n * `events` is single-consumer and provider-owned. The connection opens when\n * the layer is built and closes with its scope, so there is no connect /\n * disconnect here, and reconnects, acks and callback answering all happen\n * below this line.\n *\n * `post`, `typing` and `stream` target the ambient\n * {@link CurrentConversation}; `edit` and `react` name a message outright.\n */\nexport type MessengerService = {\n  readonly events: Stream.Stream<InboundEvent, MessengerError.MessengerError>\n\n  /** Text past `limits.maxText` goes out as several messages; the id is the last. */\n  readonly post: (\n    msg: Outbound,\n  ) => Effect.Effect<MessageId, MessengerError.MessengerError, CurrentConversation>\n\n  readonly edit: (\n    msg: MessageRef,\n    next: Outbound,\n  ) => Effect.Effect<void, MessengerError.MessengerError>\n\n  /**\n   * `emoji` in the platform's own spelling, as its `Reaction` events deliver\n   * it. Nothing is translated; one the platform rejects fails\n   * `MessengerUnsupported`.\n   */\n  readonly react: (\n    msg: MessageRef,\n    emoji: string,\n  ) => Effect.Effect<void, MessengerError.MessengerError>\n\n  /** Activity indicator, kept alive by the adapter until the scope closes. */\n  readonly typing: Effect.Effect<\n    void,\n    MessengerError.MessengerError,\n    CurrentConversation | Scope.Scope\n  >\n\n  /**\n   * Progressive delivery of a text stream; the mechanism is the adapter's.\n   * The id is the last message posted, `None` when the stream had no text.\n   */\n  readonly stream: <E, R>(\n    deltas: Stream.Stream<string, E, R>,\n    options?: StreamOptions,\n  ) => Effect.Effect<\n    Option.Option<MessageId>,\n    MessengerError.MessengerError | E,\n    R | CurrentConversation\n  >\n\n  readonly limits: MessengerLimits\n}\n\nexport class Messenger extends Context.Service<Messenger, MessengerService>()(\n  \"@betalyra/effect-uai/Messenger\",\n) {}\n\n// ---------------------------------------------------------------------------\n// Free helpers\n// ---------------------------------------------------------------------------\n\nexport const events: Stream.Stream<InboundEvent, MessengerError.MessengerError, Messenger> =\n  Stream.unwrap(Effect.map(Messenger, (m) => m.events))\n\nexport const post = (\n  msg: Outbound,\n): Effect.Effect<MessageId, MessengerError.MessengerError, Messenger | CurrentConversation> =>\n  Effect.flatMap(Messenger, (m) => m.post(msg))\n\nexport const edit = (\n  msg: MessageRef,\n  next: Outbound,\n): Effect.Effect<void, MessengerError.MessengerError, Messenger> =>\n  Effect.flatMap(Messenger, (m) => m.edit(msg, next))\n\nexport const react = (\n  msg: MessageRef,\n  emoji: string,\n): Effect.Effect<void, MessengerError.MessengerError, Messenger> =>\n  Effect.flatMap(Messenger, (m) => m.react(msg, emoji))\n\nexport const typing: Effect.Effect<\n  void,\n  MessengerError.MessengerError,\n  Messenger | CurrentConversation | Scope.Scope\n> = Effect.flatMap(Messenger, (m) => m.typing)\n\nexport const stream = <E, R>(\n  deltas: Stream.Stream<string, E, R>,\n  options?: StreamOptions,\n): Effect.Effect<\n  Option.Option<MessageId>,\n  MessengerError.MessengerError | E,\n  R | Messenger | CurrentConversation\n> => Effect.flatMap(Messenger, (m) => m.stream(deltas, options))\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAUA,MAAa,YAAY,MAAM,QAAmB;AAIlD,MAAa,YAAY,MAAM,QAAmB;AAIlD,MAAa,SAAS,MAAM,QAAgB;AAI5C,MAAa,WAAW,MAAM,QAAkB;;AAkBhD,MAAa,mBAAmB,QAC9B,IAAI,WAAW,KAAA,IAAY,IAAI,UAAU,GAAG,IAAI,QAAQ,GAAG,IAAI;AAoDjE,MAAa,eAAe,KAAK,WAAyB;AA2B1D,MAAa,eAAe,KAAK,WAAyB;AAa1D,MAAM,YAAY,MAAoB,aAAyC;CAC7E;CACA,GAAI,SAAS,YAAY,KAAA,KAAa,EAAE,SAAS,QAAQ,QAAQ;AACnE;;AAGA,MAAa,QAAQ,MAAc,YACjC,SAAS,aAAa,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO;;AAGrD,MAAa,SACX,QACA,YAEA,SACE,aAAa,MAAM;CACjB,OAAO;CACP,GAAI,SAAS,YAAY,KAAA,KAAa,EAAE,SAAS,QAAQ,QAAQ;CACjE,GAAI,SAAS,aAAa,KAAA,KAAa,EAAE,UAAU,QAAQ,SAAS;AACtE,CAAC,GACD,OACF;;AAGF,MAAa,OAAO,aAAgC,EAAE,MAAM,aAAa,IAAI,EAAE,QAAQ,CAAC,EAAE;;;;;;;AAY1F,IAAa,sBAAb,cAAyC,QAAQ,QAA8C,CAAC,CAC9F,oDACF,CAAC,CAAC,CAAC;;AAGH,MAAa,kBACV,SACS,WACR,OAAO,eAAe,QAAQ,qBAAqB,GAAG;AA0E1D,IAAa,YAAb,cAA+B,QAAQ,QAAqC,CAAC,CAC3E,gCACF,CAAC,CAAC,CAAC;AAMH,MAAa,SACX,OAAO,OAAO,OAAO,IAAI,YAAY,MAAM,EAAE,MAAM,CAAC;AAEtD,MAAa,QACX,QAEA,OAAO,QAAQ,YAAY,MAAM,EAAE,KAAK,GAAG,CAAC;AAE9C,MAAa,QACX,KACA,SAEA,OAAO,QAAQ,YAAY,MAAM,EAAE,KAAK,KAAK,IAAI,CAAC;AAEpD,MAAa,SACX,KACA,UAEA,OAAO,QAAQ,YAAY,MAAM,EAAE,MAAM,KAAK,KAAK,CAAC;AAEtD,MAAa,SAIT,OAAO,QAAQ,YAAY,MAAM,EAAE,MAAM;AAE7C,MAAa,UACX,QACA,YAKG,OAAO,QAAQ,YAAY,MAAM,EAAE,OAAO,QAAQ,OAAO,CAAC"}

package/dist/messenger/MessengerAdapter.d.mts

@@ -0,0 +1,35 @@
+import { MessengerService } from "./Messenger.mjs";
+import { Array, Duration } from "effect";
+declare namespace MessengerAdapter_d_exports {
+  export { EditableVerbs, StreamViaEditsOptions, splitForLimit, streamViaEdits };
+}
+/**
+ * Chunk `body` into pieces no longer than `limit`, breaking on paragraph,
+ * line, then word boundaries. Always yields at least one chunk, so callers
+ * have something to send even for empty input.
+ */
+declare const splitForLimit: (body: string, limit: number) => Array.NonEmptyReadonlyArray<string>;
+/** The slice of a messenger that {@link streamViaEdits} drives. */
+type EditableVerbs = Pick<MessengerService, "post" | "edit" | "limits">;
+type StreamViaEditsOptions = {
+  /** Minimum wall time between edits. Default 1 second. */
+  readonly every?: Duration.Input;
+  /** Minimum growth since the last edit before spending another. Default 40. */
+  readonly minChars?: number;
+  /** How often to honour a `MessengerRateLimited` before giving up. Default 3. */
+  readonly rateLimitRetries?: number;
+};
+/**
+ * Progressive delivery as post-then-edit, for adapters with no native
+ * streaming API. Coalesces deltas by time and growth, never resends
+ * unchanged text, waits out `MessengerRateLimited`, rolls over to a fresh
+ * message past `limits.maxText`, and always flushes the tail.
+ *
+ * The first chunk goes out as soon as any text arrives, so the message shows
+ * up immediately and fills in from there. A stream that produced no text
+ * posts nothing and yields `None`.
+ */
+declare const streamViaEdits: (verbs: EditableVerbs, options?: StreamViaEditsOptions) => MessengerService["stream"];
+//#endregion
+export { EditableVerbs, StreamViaEditsOptions, splitForLimit, streamViaEdits, MessengerAdapter_d_exports as t };
+//# sourceMappingURL=MessengerAdapter.d.mts.map

package/dist/messenger/MessengerAdapter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessengerAdapter.d.mts","names":[],"sources":["../../src/messenger/MessengerAdapter.ts"],"mappings":";;;;;;;;;;cAsCa,gBAAa,cAAgB,kBAAkB,MAAI;;KAUpD,gBAAgB,KAAK;KAErB;;WAED,QAAQ,SAAS;;WAEjB;;WAEA;;;;;;;;;;;;cAsDE,iBAAc,OACjB,eAAa,UAAY,0BAAwB"}