@segmentstream/ontology 0.0.0-stage → 0.92.1

package/dist/service/chat/delivery.js

@@ -0,0 +1,251 @@
+import { telegramMarkdownLinks, telegramTextLinks, validateTelegramPreviews, } from "../../telegram.js";
+import { randomUUID } from "node:crypto";
+import { Cause, Effect } from "effect";
+import { chatOperationId, chatPreviewDigest, } from "../../chat.js";
+import { ActionRejected, PermissionDenied } from "../../errors.js";
+import { isAllowed } from "../../permissions.js";
+import { describeChatError } from "./diagnostics.js";
+import { deliveryRequester } from "./attribution.js";
+import { deliveryFingerprint, deliveryKeyDigest, deliveryScopeDigest } from "./idempotency.js";
+import { renderTelegram, sendTelegram, TELEGRAM_MESSAGE_LIMIT } from "./providers/telegram.js";
+import { chatResolver } from "./resolve.js";
+export function makeChatDelivery(ontology, connections, archive, previews = {}) {
+    if (previews.settings) {
+        validateTelegramPreviews(previews.settings);
+    }
+    const attribution = ontology.config.chat?.attribution;
+    const separator = attribution?.separator ?? "\n\n";
+    const destination = ontology.manifest.chat?.telegram?.connection;
+    const destinationPreviews = previews.settings?.connection === destination ? previews : { ownOrigins: previews.ownOrigins };
+    return (context) => {
+        const check = (input, approved = true) => Effect.gen(function* () {
+            if (!isAllowed("agent_chat:post_message", context.principal)) {
+                return yield* new PermissionDenied({
+                    message: "agent_chat:post_message is required.",
+                    permission: "agent_chat:post_message",
+                });
+            }
+            const user = yield* context.backend.get({ entity: "user", id: context.principal.id });
+            if (user.active !== true || user.kind !== context.principal.kind) {
+                return yield* new PermissionDenied({ message: "The requester is inactive." });
+            }
+            const requester = yield* deliveryRequester(context.caller, context.principal, String(user.name), attribution);
+            if (context.caller.kind === "runtime" &&
+                (context.backend.agents === undefined ||
+                    (yield* context.backend.agents.actingMember(context.principal.id)) === undefined)) {
+                return yield* new PermissionDenied({
+                    message: "The requester must still be paired and active.",
+                });
+            }
+            const target = yield* chatResolver(context.backend, context.principal).resolve(input.chat);
+            const connection = ontology.manifest.chat?.telegram?.connection;
+            const replyTo = input.replyTo ?? null;
+            const plainText = `${input.text}${separator}${requester.attribution}`;
+            if (target.provider !== "telegram" || !connection) {
+                return yield* new ActionRejected({
+                    message: "Chat posting requires a configured Telegram provider connection.",
+                });
+            }
+            const finalText = yield* Effect.try({
+                try: () => renderTelegram(input.text, requester.attribution, separator),
+                catch: (cause) => new ActionRejected({ message: "The Markdown could not be rendered.", cause }),
+            });
+            if (!input.text.trim() ||
+                finalText.length > TELEGRAM_MESSAGE_LIMIT ||
+                plainText.length > TELEGRAM_MESSAGE_LIMIT ||
+                !/^-?[1-9][0-9]*$/.test(target.external_id) ||
+                (replyTo !== null &&
+                    (!/^[1-9][0-9]*$/.test(replyTo) || !Number.isSafeInteger(Number(replyTo)))) ||
+                !input.idempotencyKey ||
+                input.idempotencyKey.length > 512) {
+                return yield* new ActionRejected({
+                    message: "The exact attributed message or reply target is invalid or too long. Nothing was truncated.",
+                });
+            }
+            const preview = {
+                chatId: target.id,
+                provider: target.provider,
+                externalId: target.external_id,
+                title: target.title,
+                attribution: requester.attribution,
+                text: input.text,
+                finalText,
+                replyTo,
+            };
+            if (context.caller.kind === "runtime" && approved) {
+                const envelope = context.envelope;
+                if (!envelope?.source ||
+                    !envelope.expected ||
+                    !envelope.operation_id ||
+                    envelope.operation_id !== chatOperationId(envelope.session_id, envelope.call_id) ||
+                    input.idempotencyKey !== envelope.operation_id ||
+                    envelope.expected.chat_id !== target.id ||
+                    envelope.expected.digest !== chatPreviewDigest(preview) ||
+                    (envelope.source.provider === target.provider &&
+                        envelope.source.chat_id === target.external_id)) {
+                    return yield* new ActionRejected({
+                        message: "A frozen approved cross-chat preview matching this call is required.",
+                    });
+                }
+            }
+            return { target, requester, connection, preview };
+        });
+        const report = (phase, cause) => Effect.logWarning("ontology.chat.delivery_diagnostic").pipe(Effect.annotateLogs({
+            phase,
+            requestId: context.requestId,
+            error: describeChatError(cause, (text) => context.identityToken ? text.split(context.identityToken).join("[redacted]") : text),
+        }));
+        return {
+            preview: (input) => check(input, false).pipe(Effect.map(({ preview }) => preview)),
+            validate: (input) => check(input).pipe(Effect.asVoid),
+            post: (input) => Effect.gen(function* () {
+                const { target, requester, connection, preview } = yield* check(input);
+                const operationId = context.envelope?.operation_id ?? randomUUID();
+                const scope = deliveryScopeDigest({
+                    via: requester.via,
+                    subjectId: requester.id,
+                    clientId: requester.clientId,
+                });
+                const key = deliveryKeyDigest(input.idempotencyKey);
+                const fingerprint = deliveryFingerprint(preview, requester);
+                const event = {
+                    eventId: `chat-delivery:${operationId}:reserve`,
+                    operationId,
+                    provider: target.provider,
+                    chatId: target.external_id,
+                    chatType: target.kind,
+                    threadId: null,
+                    participantIds: target.participantIds,
+                    senderId: "agent",
+                    senderName: "agent",
+                    senderIsBot: true,
+                    kind: "outbound",
+                    messageId: null,
+                    replyToMessageId: preview.replyTo,
+                    sessionId: context.envelope?.session_id ?? null,
+                    turnId: null,
+                    // The claim binds text immutably. Keep the source here and the actual wire payload
+                    // in argsSummary, which can record the plain retry without changing that binding.
+                    text: `${input.text}${separator}${requester.attribution}`,
+                    decision: null,
+                    reason: null,
+                    toolCallId: null,
+                    toolName: null,
+                    argsSummary: JSON.stringify({ text: preview.finalText, parse_mode: "MarkdownV2" }),
+                    status: "requested",
+                    attachments: [],
+                    requestedBy: requester,
+                    url: null,
+                    at: new Date().toISOString(),
+                };
+                const reserve = yield* archive({
+                    event,
+                    delivery: { phase: "reserve", scope, key, fingerprint },
+                    identityToken: context.identityToken,
+                }).pipe(Effect.tapError((error) => report("reserve", error)), Effect.mapError((cause) => new ActionRejected({
+                    cause,
+                    message: cause.diagnostic === "chat_archive_conflict"
+                        ? "This idempotency key is bound to another delivery. " +
+                            "Replay the original input to recover its receipt."
+                        : "Delivery could not be reserved. Retry only the same idempotency key; no send was authorized.",
+                })));
+                if (!reserve.claimed) {
+                    if (reserve.version !== 1 || !reserve.duplicate || reserve.claimId !== undefined) {
+                        return yield* new ActionRejected({
+                            message: "The archive did not return a valid delivery receipt.",
+                        });
+                    }
+                    if (reserve.status === "failed") {
+                        return yield* new ActionRejected({
+                            message: "This operation was refused. Its idempotency key is consumed.",
+                        });
+                    }
+                    return {
+                        status: reserve.status,
+                        message_id: reserve.messageId,
+                        url: reserve.url,
+                        duplicate: true,
+                        history_recorded: reserve.historyRecorded,
+                    };
+                }
+                if (reserve.version !== 1 ||
+                    reserve.duplicate ||
+                    !reserve.claimId ||
+                    reserve.operationId !== operationId ||
+                    reserve.status !== "uncertain" ||
+                    reserve.historyRecorded ||
+                    reserve.messageId !== null ||
+                    reserve.url !== null) {
+                    return yield* new ActionRejected({
+                        message: "The archive did not grant a fresh delivery claim.",
+                    });
+                }
+                const outcome = yield* sendTelegram({
+                    destination: target,
+                    connection,
+                    finalText: preview.finalText,
+                    formattedLinks: [
+                        ...telegramMarkdownLinks(preview.text),
+                        ...telegramTextLinks(separator),
+                        ...telegramTextLinks(preview.attribution),
+                    ],
+                    previews: destinationPreviews,
+                    plainText: event.text,
+                    replyTo: preview.replyTo,
+                    transport: connections({
+                        identityToken: context.identityToken,
+                        audit: {
+                            action: "agent_chat.post_message",
+                            principalId: context.principal.id,
+                            requestId: context.requestId,
+                        },
+                    }),
+                });
+                if (outcome.cause !== undefined) {
+                    yield* report("provider", outcome.cause);
+                }
+                const saved = yield* archive({
+                    event: {
+                        ...event,
+                        eventId: `chat-delivery:${operationId}:receipt`,
+                        status: outcome.status,
+                        argsSummary: JSON.stringify(outcome.payload),
+                        messageId: outcome.messageId,
+                        url: outcome.url,
+                    },
+                    delivery: { phase: "receipt", scope, key, fingerprint, claimId: reserve.claimId },
+                    identityToken: context.identityToken,
+                }).pipe(Effect.exit);
+                let historyRecorded = false;
+                if (saved._tag === "Failure") {
+                    yield* report("receipt", Cause.squash(saved.cause));
+                }
+                else {
+                    historyRecorded =
+                        saved.value.version === 1 &&
+                            !saved.value.claimed &&
+                            saved.value.operationId === operationId &&
+                            saved.value.status === outcome.status &&
+                            saved.value.messageId === outcome.messageId &&
+                            saved.value.url === outcome.url &&
+                            saved.value.historyRecorded;
+                    if (!historyRecorded) {
+                        yield* report("receipt", new Error("The archive did not acknowledge the exact delivery outcome."));
+                    }
+                }
+                if (outcome.status === "failed") {
+                    return yield* new ActionRejected({
+                        message: "The provider refused the message. This operation key is consumed.",
+                    });
+                }
+                return {
+                    status: outcome.status,
+                    message_id: outcome.messageId,
+                    url: outcome.url,
+                    duplicate: false,
+                    history_recorded: historyRecorded,
+                };
+            }),
+        };
+    };
+}

package/dist/service/chat/diagnostics.d.ts

@@ -0,0 +1,2 @@
+/** Every cause and aggregate branch, with cycle protection and credential-value redaction. */
+export declare function describeChatError(error: unknown, redact: (text: string) => string): string;

package/dist/service/chat/diagnostics.js

@@ -0,0 +1,35 @@
+/** Every cause and aggregate branch, with cycle protection and credential-value redaction. */
+export function describeChatError(error, redact) {
+    const seen = new Set();
+    const pending = [{ value: error, label: "" }];
+    const lines = [];
+    while (pending.length > 0) {
+        const { value, label } = pending.pop();
+        if (value === null || typeof value !== "object") {
+            lines.push(`${label}${String(value)}`);
+            continue;
+        }
+        if (seen.has(value)) {
+            lines.push(`${label}[previously reported cause]`);
+            continue;
+        }
+        seen.add(value);
+        const record = value;
+        const name = typeof record.name === "string" ? record.name : String(record._tag ?? "Error");
+        const message = typeof record.message === "string" ? record.message : "Unknown failure";
+        const head = typeof record.stack === "string" ? record.stack : `${name}: ${message}`;
+        const diagnostic = [record.code, record.diagnostic]
+            .filter((part) => typeof part === "string")
+            .join("; ");
+        lines.push(`${label}${head}${diagnostic ? ` [${diagnostic}]` : ""}`);
+        if (Array.isArray(record.errors)) {
+            for (let index = record.errors.length - 1; index >= 0; index--) {
+                pending.push({ value: record.errors[index], label: `aggregate cause ${index + 1}: ` });
+            }
+        }
+        if (record.cause !== undefined) {
+            pending.push({ value: record.cause, label: "caused by: " });
+        }
+    }
+    return redact(lines.join("\n"));
+}

package/dist/service/chat/envelope.d.ts

@@ -0,0 +1,96 @@
+import { Context, Effect, Schema } from "effect";
+import { ActionRejected, PermissionDenied } from "../../errors.js";
+import type { CallerContext } from "../caller-context.js";
+declare const RuntimeEnvelope: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly session_id: Schema.String;
+    readonly call_id: Schema.String;
+    readonly operation_id: Schema.optionalKey<Schema.String>;
+    readonly source: Schema.optionalKey<Schema.Struct<{
+        readonly provider: Schema.Literal<"telegram">;
+        readonly chat_id: Schema.String;
+        readonly thread_id: Schema.String;
+        readonly message_id: Schema.optionalKey<Schema.String>;
+        readonly reply_to_message_id: Schema.optionalKey<Schema.String>;
+        readonly callback_query_id: Schema.optionalKey<Schema.String>;
+        readonly sender: Schema.optionalKey<Schema.String>;
+        readonly attachments: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly file_id: Schema.String;
+            readonly file_unique_id: Schema.optionalKey<Schema.String>;
+            readonly kind: Schema.Literals<readonly ["photo", "document", "voice", "audio", "video", "video_note", "sticker", "animation"]>;
+            readonly media_type: Schema.optionalKey<Schema.String>;
+            readonly staged_id: Schema.String;
+        }>>>;
+    }>>;
+    readonly expected: Schema.optionalKey<Schema.Struct<{
+        readonly chat_id: Schema.String;
+        readonly digest: Schema.String;
+    }>>;
+}>;
+export type RuntimeChatEnvelope = typeof RuntimeEnvelope.Type;
+declare const CurrentChatCall_base: Context.ServiceClass<CurrentChatCall, "@segmentstream/ontology/CurrentChatCall", {
+    readonly version: 1;
+    readonly session_id: string;
+    readonly call_id: string;
+    readonly source?: {
+        readonly provider: "telegram";
+        readonly chat_id: string;
+        readonly thread_id: string;
+        readonly message_id?: string | undefined;
+        readonly reply_to_message_id?: string | undefined;
+        readonly callback_query_id?: string | undefined;
+        readonly sender?: string | undefined;
+        readonly attachments?: readonly {
+            readonly kind: "photo" | "document" | "voice" | "audio" | "video" | "video_note" | "sticker" | "animation";
+            readonly file_id: string;
+            readonly staged_id: string;
+            readonly file_unique_id?: string | undefined;
+            readonly media_type?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    readonly operation_id?: string | undefined;
+    readonly expected?: {
+        readonly chat_id: string;
+        readonly digest: string;
+    } | undefined;
+}>;
+export declare class CurrentChatCall extends CurrentChatCall_base {
+}
+/** Consume Eve's all-tool application argument before any strict per-tool decoding. */
+export declare function consumeChatEnvelope(args: Readonly<Record<string, unknown>>, caller: CallerContext): Effect.Effect<{
+    input: {
+        readonly [x: string]: unknown;
+    };
+    envelope: undefined;
+} | {
+    input: {
+        readonly [x: string]: unknown;
+    };
+    envelope: {
+        readonly version: 1;
+        readonly session_id: string;
+        readonly call_id: string;
+        readonly source?: {
+            readonly provider: "telegram";
+            readonly chat_id: string;
+            readonly thread_id: string;
+            readonly message_id?: string | undefined;
+            readonly reply_to_message_id?: string | undefined;
+            readonly callback_query_id?: string | undefined;
+            readonly sender?: string | undefined;
+            readonly attachments?: readonly {
+                readonly kind: "photo" | "document" | "voice" | "audio" | "video" | "video_note" | "sticker" | "animation";
+                readonly file_id: string;
+                readonly staged_id: string;
+                readonly file_unique_id?: string | undefined;
+                readonly media_type?: string | undefined;
+            }[] | undefined;
+        } | undefined;
+        readonly operation_id?: string | undefined;
+        readonly expected?: {
+            readonly chat_id: string;
+            readonly digest: string;
+        } | undefined;
+    };
+}, ActionRejected | PermissionDenied, never>;
+export {};

package/dist/service/chat/envelope.js

@@ -0,0 +1,39 @@
+import { RuntimeSource } from "../../runtime-source.js";
+import { Context, Effect, Schema } from "effect";
+import { ActionRejected, PermissionDenied } from "../../errors.js";
+import { chatOperationId } from "../../chat.js";
+const Id = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(512));
+const RuntimeEnvelope = Schema.Struct({
+    version: Schema.Literal(1),
+    session_id: Id,
+    call_id: Id,
+    operation_id: Schema.optionalKey(Id),
+    source: Schema.optionalKey(RuntimeSource),
+    expected: Schema.optionalKey(Schema.Struct({ chat_id: Id, digest: Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/)) })),
+});
+export class CurrentChatCall extends Context.Service()("@segmentstream/ontology/CurrentChatCall") {
+}
+/** Consume Eve's all-tool application argument before any strict per-tool decoding. */
+export function consumeChatEnvelope(args, caller) {
+    return Effect.gen(function* () {
+        const { _segmentstream: envelope, ...input } = args;
+        if (!Object.hasOwn(args, "_segmentstream")) {
+            return { input, envelope: undefined };
+        }
+        if (caller.kind !== "runtime") {
+            return yield* new PermissionDenied({
+                message: "Runtime arguments require verified agent runtime identity.",
+            });
+        }
+        const parsed = yield* Schema.decodeUnknownEffect(RuntimeEnvelope)(envelope, {
+            onExcessProperty: "error",
+        }).pipe(Effect.mapError(() => new ActionRejected({ message: "Invalid agent runtime call metadata." })));
+        if (parsed.operation_id !== undefined &&
+            parsed.operation_id !== chatOperationId(parsed.session_id, parsed.call_id)) {
+            return yield* new ActionRejected({
+                message: "The runtime operation does not match its call.",
+            });
+        }
+        return { input, envelope: parsed };
+    });
+}

package/dist/service/chat/idempotency.d.ts

@@ -0,0 +1,19 @@
+import type { ChatPreview } from "../../chat.js";
+import type { ConversationRequester } from "./attribution.js";
+interface DeliveryScopeIdentifiers {
+    readonly via: ConversationRequester["via"];
+    readonly subjectId: string;
+    readonly clientId: string | null;
+}
+/**
+ * An archive namespace, not a password/credential verifier. Only authenticated public
+ * identifiers enter this digest: caller kind, subject ID and registered OAuth client_id.
+ * Authentication projects the client ID separately from tokens, secretHash and grants;
+ * never serialize a caller, client or grant record here. Preserve this tuple's encoding
+ * (including runtime's original kind) so existing sent/uncertain claims stay consumed.
+ */
+export declare function deliveryScopeDigest(identifiers: DeliveryScopeIdentifiers): string;
+export declare const deliveryKeyDigest: (idempotencyKey: string) => string;
+/** Bind the exact post and public attribution fields; ignore unrelated record properties. */
+export declare function deliveryFingerprint(preview: ChatPreview, requester: ConversationRequester): string;
+export {};

package/dist/service/chat/idempotency.js

@@ -0,0 +1,37 @@
+import { createHash } from "node:crypto";
+const digest = (serialized) => createHash("sha256").update(serialized).digest("hex");
+/**
+ * An archive namespace, not a password/credential verifier. Only authenticated public
+ * identifiers enter this digest: caller kind, subject ID and registered OAuth client_id.
+ * Authentication projects the client ID separately from tokens, secretHash and grants;
+ * never serialize a caller, client or grant record here. Preserve this tuple's encoding
+ * (including runtime's original kind) so existing sent/uncertain claims stay consumed.
+ */
+export function deliveryScopeDigest(identifiers) {
+    return digest(JSON.stringify([
+        identifiers.via === "hq" ? "runtime" : identifiers.via,
+        identifiers.subjectId,
+        identifiers.via === "oauth" ? identifiers.clientId : null,
+    ]));
+}
+export const deliveryKeyDigest = (idempotencyKey) => digest(JSON.stringify(idempotencyKey));
+/** Bind the exact post and public attribution fields; ignore unrelated record properties. */
+export function deliveryFingerprint(preview, requester) {
+    return digest(JSON.stringify([
+        preview.chatId,
+        preview.provider,
+        preview.externalId,
+        preview.finalText,
+        preview.text,
+        preview.replyTo,
+        {
+            id: requester.id,
+            kind: requester.kind,
+            name: requester.name,
+            via: requester.via,
+            clientId: requester.clientId,
+            clientName: requester.clientName,
+            attribution: requester.attribution,
+        },
+    ]));
+}

package/dist/service/chat/providers/telegram.d.ts

@@ -0,0 +1,36 @@
+import { type TelegramPreviewContext } from "../../../telegram.js";
+import { Effect } from "effect";
+import { type ConnectionTransport } from "../../../connection.js";
+import type { Destination } from "../resolve.js";
+export declare const TELEGRAM_MESSAGE_LIMIT = 4096;
+/** Render source independently so user Markdown cannot open an entity around the footer. */
+export declare function renderTelegram(markdown: string, attribution: string, separator?: string): string;
+interface TelegramPayload {
+    readonly text: string;
+    readonly parse_mode?: "MarkdownV2";
+}
+export interface ProviderOutcome {
+    readonly payload: TelegramPayload;
+    readonly status: "sent" | "uncertain" | "failed";
+    readonly messageId: string | null;
+    readonly url: string | null;
+    readonly cause?: unknown;
+}
+interface TelegramSend {
+    readonly transport: ConnectionTransport["Service"];
+    readonly connection: string;
+    readonly destination: Destination;
+    /** Links parsed before MarkdownV2 escaping, with the literal attribution added separately. */
+    readonly formattedLinks?: readonly string[];
+    readonly previews?: TelegramPreviewContext;
+    readonly finalText: string;
+    readonly plainText: string;
+    readonly replyTo: string | null;
+    readonly link_preview_options?: Readonly<Record<string, unknown>>;
+    readonly disable_web_page_preview?: boolean;
+}
+/** One proxy POST, except one plain retry after a definite 400 entity parse refusal.
+ * Never retry an unknown outcome; never chunk, truncate or invoke an agent.
+ */
+export declare function sendTelegram(input: TelegramSend): Effect.Effect<ProviderOutcome>;
+export {};

package/dist/service/chat/providers/telegram.js

@@ -0,0 +1,133 @@
+import { telegramMarkdownLinks, telegramTextLinks, telegramPreviewOptions, } from "../../../telegram.js";
+import { escapeMarkdownV2, TelegramFormatConverter } from "@chat-adapter/telegram";
+import { Cause, Effect } from "effect";
+import { ConnectionError } from "../../../connection.js";
+export const TELEGRAM_MESSAGE_LIMIT = 4096;
+const converter = new TelegramFormatConverter();
+/** Render source independently so user Markdown cannot open an entity around the footer. */
+export function renderTelegram(markdown, attribution, separator = "\n\n") {
+    return `${converter.fromMarkdown(markdown)}${escapeMarkdownV2(separator)}_${escapeMarkdownV2(attribution)}_`;
+}
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : {};
+/** One proxy POST, except one plain retry after a definite 400 entity parse refusal.
+ * Never retry an unknown outcome; never chunk, truncate or invoke an agent.
+ */
+export function sendTelegram(input) {
+    return Effect.gen(function* () {
+        const formatted = yield* attemptTelegram(input, {
+            text: input.finalText,
+            parse_mode: "MarkdownV2",
+        });
+        if (!formatted.formattingRefused) {
+            return formatted;
+        }
+        const plain = yield* attemptTelegram(input, { text: input.plainText });
+        return {
+            ...plain,
+            cause: plain.cause === undefined
+                ? formatted.cause
+                : new AggregateError([formatted.cause, plain.cause], "Telegram plain retry failed."),
+        };
+    });
+}
+function attemptTelegram(input, payload) {
+    return Effect.gen(function* () {
+        const result = yield* input.transport
+            .request({
+            connection: input.connection,
+            api: "bot",
+            method: "POST",
+            path: "/sendMessage",
+            headers: [["content-type", "application/json"]],
+            body: new TextEncoder().encode(JSON.stringify({
+                chat_id: input.destination.external_id,
+                ...payload,
+                ...telegramPreviewOptions({
+                    link_preview_options: input.link_preview_options,
+                    disable_web_page_preview: input.disable_web_page_preview,
+                }, payload.parse_mode === "MarkdownV2"
+                    ? (input.formattedLinks ?? telegramMarkdownLinks(input.plainText))
+                    : telegramTextLinks(payload.text), input.previews),
+                ...(input.replyTo === null
+                    ? {}
+                    : {
+                        reply_parameters: {
+                            message_id: Number(input.replyTo),
+                            allow_sending_without_reply: false,
+                        },
+                    }),
+            })),
+        })
+            .pipe(Effect.exit);
+        if (result._tag === "Failure") {
+            const cause = Cause.squash(result.cause);
+            const definite = cause instanceof ConnectionError &&
+                [
+                    "authorization_required",
+                    "not_deployed",
+                    "not_granted",
+                    "invalid_request",
+                    "refused",
+                ].includes(cause.reason);
+            return {
+                payload,
+                status: definite ? "failed" : "uncertain",
+                messageId: null,
+                url: null,
+                cause,
+            };
+        }
+        let body;
+        try {
+            body = record(JSON.parse(new TextDecoder().decode(result.value.body)));
+        }
+        catch (cause) {
+            return { payload, status: "uncertain", messageId: null, url: null, cause };
+        }
+        if (body.ok === false) {
+            return {
+                payload,
+                formattingRefused: result.value.status === 400 &&
+                    typeof body.description === "string" &&
+                    /can't parse entities/iu.test(body.description),
+                status: "failed",
+                messageId: null,
+                url: null,
+                cause: new Error(typeof body.description === "string" ? body.description : "Telegram refused the message."),
+            };
+        }
+        const message = record(body.result);
+        const chat = record(message.chat);
+        if (result.value.status < 200 ||
+            result.value.status >= 300 ||
+            body.ok !== true ||
+            !Number.isSafeInteger(message.message_id) ||
+            Number(message.message_id) < 1 ||
+            String(chat.id) !== input.destination.external_id ||
+            (input.replyTo !== null &&
+                String(record(message.reply_to_message).message_id) !== input.replyTo)) {
+            return {
+                payload,
+                status: "uncertain",
+                messageId: null,
+                url: null,
+                cause: new Error("Telegram success could not be verified."),
+            };
+        }
+        const messageId = String(message.message_id);
+        const username = typeof chat.username === "string" && /^[A-Za-z][A-Za-z0-9_]{3,31}$/.test(chat.username)
+            ? chat.username
+            : null;
+        const privateChannel = /^-100[1-9][0-9]*$/.test(input.destination.external_id);
+        const url = input.destination.kind === "private"
+            ? null
+            : username !== null
+                ? `https://t.me/${username}/${messageId}`
+                : privateChannel
+                    ? `https://t.me/c/${input.destination.external_id.slice(4)}/${messageId}`
+                    : null;
+        return { payload, status: "sent", messageId, url };
+    });
+}