@relaymessenger/chat-sdk-adapter 0.2.1 → 0.3.0-staging.0

package/dist/src/chunk.d.ts

@@ -1,25 +0,0 @@
-import type { RenderedText } from "./format.js";
-/** Relay caps one text part at 8 KB of UTF-8. */
-export declare const MAX_TEXT_PART_BYTES = 8192;
-/**
- * Relay caps one send call at 32 ordered parts. The server splits the call at
- * ingest: each visible non-media part becomes its own message, contiguous
- * media parts stay one media message, and a voice memo always commits
- * alone. The name survives from when one call
- * committed one message; it still bounds a single POST.
- */
-export declare const MAX_PARTS_PER_MESSAGE = 32;
-export declare function utf8Length(value: string): number;
-/**
- * Split rendered text into parts that each fit Relay's per-part ceiling.
- * Nothing is truncated: a long reply becomes more parts, and if it needs more
- * than one message the caller sends the overflow as follow-up messages.
- *
- * A cut consumes the whitespace run it lands on, and nothing else. Every part
- * draws as its own balloon on iOS
- * (`Relay-iOS/Relay/Views/Transcript/RelayCompositePartsModel.swift:6-7`), so a
- * part must not open with a blank line or close with a trailing space; the
- * whitespace at the seam is the only thing a split drops, and it is whitespace
- * between two balloons, which nobody can see.
- */
-export declare function chunkRenderedText(rendered: RenderedText, maxBytes?: number): RenderedText[];

package/dist/src/chunk.js

@@ -1,108 +0,0 @@
-/** Relay caps one text part at 8 KB of UTF-8. */
-export const MAX_TEXT_PART_BYTES = 8192;
-/**
- * Relay caps one send call at 32 ordered parts. The server splits the call at
- * ingest: each visible non-media part becomes its own message, contiguous
- * media parts stay one media message, and a voice memo always commits
- * alone. The name survives from when one call
- * committed one message; it still bounds a single POST.
- */
-export const MAX_PARTS_PER_MESSAGE = 32;
-const encoder = new TextEncoder();
-export function utf8Length(value) {
-    return encoder.encode(value).length;
-}
-/**
- * Largest UTF-16 index whose prefix still fits in `maxBytes` of UTF-8, always
- * landing on a code point boundary so a surrogate pair is never cut in half.
- */
-function byteLimitIndex(text, maxBytes) {
-    let bytes = 0;
-    let index = 0;
-    for (const codePoint of text) {
-        const size = encoder.encode(codePoint).length;
-        if (bytes + size > maxBytes)
-            return index;
-        bytes += size;
-        index += codePoint.length;
-    }
-    return text.length;
-}
-/**
- * Prefer a natural break inside the trailing quarter of the window: a blank
- * line, then a line break, then whitespace. A hard cut is the last resort, and
- * it still lands on a code point boundary.
- */
-function breakIndex(text, limit) {
-    if (limit >= text.length)
-        return text.length;
-    const floor = Math.max(1, Math.floor(limit * 0.75));
-    for (const separator of ["\n\n", "\n", " "]) {
-        const found = text.lastIndexOf(separator, limit - separator.length);
-        if (found >= floor)
-            return found + separator.length;
-    }
-    return limit;
-}
-function sliceStyles(styles, start, end) {
-    const out = [];
-    for (const run of styles) {
-        const from = Math.max(run.start, start);
-        const to = Math.min(run.start + run.length, end);
-        if (to <= from)
-            continue;
-        out.push({ start: from - start, length: to - from, styles: run.styles });
-    }
-    return out;
-}
-/** How much whitespace sits at `from`, which a cut there consumes. */
-function whitespaceRunLength(text, from) {
-    const run = /^\s+/.exec(text.slice(from));
-    return run ? run[0].length : 0;
-}
-/**
- * Split rendered text into parts that each fit Relay's per-part ceiling.
- * Nothing is truncated: a long reply becomes more parts, and if it needs more
- * than one message the caller sends the overflow as follow-up messages.
- *
- * A cut consumes the whitespace run it lands on, and nothing else. Every part
- * draws as its own balloon on iOS
- * (`Relay-iOS/Relay/Views/Transcript/RelayCompositePartsModel.swift:6-7`), so a
- * part must not open with a blank line or close with a trailing space; the
- * whitespace at the seam is the only thing a split drops, and it is whitespace
- * between two balloons, which nobody can see.
- */
-export function chunkRenderedText(rendered, maxBytes = MAX_TEXT_PART_BYTES) {
-    if (!rendered.text)
-        return [];
-    if (utf8Length(rendered.text) <= maxBytes)
-        return [rendered];
-    const chunks = [];
-    let cursor = 0;
-    while (cursor < rendered.text.length) {
-        // A break separator shorter than the whitespace run it sits in leaves the
-        // rest of that run at the cursor. Step over it, or the next part opens
-        // with it: trimming only the tail cannot reach it.
-        const lead = whitespaceRunLength(rendered.text, cursor);
-        if (lead > 0) {
-            cursor += lead;
-            continue;
-        }
-        const remainder = rendered.text.slice(cursor);
-        const limit = byteLimitIndex(remainder, maxBytes);
-        // A single code point wider than the ceiling cannot happen (Relay's
-        // ceiling is kilobytes), but a zero-length step would spin forever.
-        const cut = limit <= 0 ? remainder.length : breakIndex(remainder, limit);
-        const end = cursor + Math.max(1, cut);
-        const text = rendered.text.slice(cursor, end);
-        const trimmed = text.replace(/\s+$/, "");
-        if (trimmed) {
-            chunks.push({
-                text: trimmed,
-                styles: sliceStyles(rendered.styles, cursor, cursor + trimmed.length),
-            });
-        }
-        cursor = end;
-    }
-    return chunks;
-}

package/dist/src/client.d.ts

@@ -1,112 +0,0 @@
-import type { RelayAttachment, RelayConversation, RelayMessage, RelayOutgoingPart, RelayReactionType, RelaySendResult, RelayUserProfile } from "./types.js";
-export interface RelayClientOptions {
-    /** Agent Token (`rly_live_...`). */
-    token: string;
-    /** Defaults to Relay production. */
-    baseUrl?: string;
-    fetch?: typeof fetch;
-}
-export interface RelaySendOptions {
-    conversationId: string;
-    parts: RelayOutgoingPart[];
-    idempotencyKey: string;
-    invocationId?: string;
-    replyTo?: {
-        messageId: string;
-    };
-}
-export interface RelayReactionOptions {
-    messageId: string;
-    operation: "add" | "remove";
-    type: RelayReactionType;
-    emoji?: string;
-    /**
-     * Anchor the reaction on one part of a media message. Only media messages
-     * carry addressable parts (per-photo reaction pills); a text or card
-     * message takes whole-message reactions only, so leave this unset there.
-     */
-    partIndex?: number;
-}
-export interface RelayHistoryOptions {
-    conversationId: string;
-    limit?: number;
-    beforeSequence?: number;
-}
-export interface RelayUploadOptions {
-    body: Uint8Array;
-    contentType?: string;
-    filename?: string;
-}
-export declare class RelayApiError extends Error {
-    readonly status: number;
-    readonly code: string;
-    constructor(status: number, code: string, message: string);
-}
-/**
- * Minimal Relay v1 client covering exactly what the Chat SDK adapter calls.
- * Raw HTTPS remains the canonical contract; see
- * https://docs.relayapp.im/api-reference/overview.
- */
-export declare class RelayClient {
-    private readonly token;
-    private readonly baseUrl;
-    private readonly fetchImpl;
-    constructor(options: RelayClientOptions);
-    private authHeaders;
-    private json;
-    /** `POST /v1/messages`. The idempotency key is mandatory on this route. */
-    send(options: RelaySendOptions): Promise<RelaySendResult>;
-    /**
-     * `PATCH /v1/messages/{id}`. Relay allows edits for 15 minutes and at most
-     * five revisions, and accepts exactly one text part: an edit replaces one
-     * message's text, and anything else answers 422.
-     */
-    edit(messageId: string, parts: RelayOutgoingPart[]): Promise<{
-        message: RelayMessage;
-    }>;
-    /** `DELETE /v1/messages/{id}`. Relay allows unsend for two minutes. */
-    unsend(messageId: string): Promise<{
-        message: RelayMessage;
-    }>;
-    /** `POST /v1/messages/{id}/reactions`. One route adds and removes. */
-    react(options: RelayReactionOptions): Promise<void>;
-    /**
-     * `POST /v1/conversations/{id}/typing`. Ephemeral: pushed to live devices,
-     * never entering the event log. Relay also exposes `/responding`, which
-     * commits a Read receipt before it starts typing; this adapter keeps the two
-     * apart so `markAsRead` stays the only call that moves a watermark.
-     */
-    typing(options: {
-        conversationId: string;
-        started?: boolean;
-        label?: string;
-        invocationId?: string;
-    }): Promise<void>;
-    /**
-     * `POST /v1/conversations/{id}/read`. Watermark semantics: everything
-     * through `messageId` is read. Older or repeated targets are no-ops.
-     */
-    markRead(conversationId: string, messageId: string): Promise<void>;
-    /** `GET /v1/conversations/{id}/messages`, newest first. */
-    history(options: RelayHistoryOptions): Promise<{
-        messages: RelayMessage[];
-    }>;
-    /** `GET /v1/conversations/{id}`. */
-    conversation(conversationId: string): Promise<{
-        conversation: RelayConversation;
-    }>;
-    /**
-     * `GET /v1/users/{id}`. Scoped: the user must currently share an active
-     * conversation with this agent, so an unknown id answers 404 rather than
-     * confirming that an account exists.
-     */
-    user(userId: string): Promise<{
-        user: RelayUserProfile;
-    }>;
-    /**
-     * `POST /v1/attachments`. One raw body, `Content-Length` required and
-     * verified against the stored object. Used for Chat SDK file uploads and for
-     * attachments that arrive as bytes rather than a public URL.
-     */
-    upload(options: RelayUploadOptions): Promise<RelayAttachment>;
-}

package/dist/src/client.js

@@ -1,180 +0,0 @@
-export class RelayApiError extends Error {
-    status;
-    code;
-    constructor(status, code, message) {
-        super(message);
-        this.status = status;
-        this.code = code;
-        this.name = "RelayApiError";
-    }
-}
-const DEFAULT_BASE_URL = "https://api.relayapp.im";
-async function raiseForStatus(response) {
-    if (response.ok)
-        return;
-    let code = "unknown";
-    let message = `${response.status}`;
-    try {
-        const body = (await response.json());
-        code = body.error?.code ?? code;
-        message = body.error?.message ?? message;
-    }
-    catch {
-        // non-JSON error body; keep the status text
-    }
-    throw new RelayApiError(response.status, code, message);
-}
-/**
- * Minimal Relay v1 client covering exactly what the Chat SDK adapter calls.
- * Raw HTTPS remains the canonical contract; see
- * https://docs.relayapp.im/api-reference/overview.
- */
-export class RelayClient {
-    token;
-    baseUrl;
-    fetchImpl;
-    constructor(options) {
-        if (!options.token)
-            throw new Error("Relay Agent Token is required");
-        this.token = options.token;
-        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
-        // Bound to the global object because the call sites invoke this through a
-        // property, which would otherwise pass the client as `this`. undici accepts
-        // that; workerd rejects it with `Illegal invocation`, so an unbound fetch
-        // fails every request on Cloudflare Workers. Binding a caller-supplied
-        // fetch is safe: an already-bound function ignores a later `bind`.
-        this.fetchImpl = (options.fetch ?? globalThis.fetch).bind(globalThis);
-    }
-    authHeaders(extra) {
-        return { Authorization: `Bearer ${this.token}`, ...extra };
-    }
-    async json(path, init) {
-        const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
-            ...init,
-            headers: this.authHeaders(init.headers),
-        });
-        await raiseForStatus(response);
-        return (await response.json());
-    }
-    /** `POST /v1/messages`. The idempotency key is mandatory on this route. */
-    async send(options) {
-        return this.json("/v1/messages", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "Idempotency-Key": options.idempotencyKey,
-            },
-            body: JSON.stringify({
-                conversation_id: options.conversationId,
-                parts: options.parts,
-                ...(options.invocationId ? { invocation_id: options.invocationId } : {}),
-                ...(options.replyTo
-                    ? { reply_to: { message_id: options.replyTo.messageId } }
-                    : {}),
-            }),
-        });
-    }
-    /**
-     * `PATCH /v1/messages/{id}`. Relay allows edits for 15 minutes and at most
-     * five revisions, and accepts exactly one text part: an edit replaces one
-     * message's text, and anything else answers 422.
-     */
-    async edit(messageId, parts) {
-        return this.json(`/v1/messages/${encodeURIComponent(messageId)}`, {
-            method: "PATCH",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ parts }),
-        });
-    }
-    /** `DELETE /v1/messages/{id}`. Relay allows unsend for two minutes. */
-    async unsend(messageId) {
-        return this.json(`/v1/messages/${encodeURIComponent(messageId)}`, { method: "DELETE" });
-    }
-    /** `POST /v1/messages/{id}/reactions`. One route adds and removes. */
-    async react(options) {
-        const response = await this.fetchImpl(`${this.baseUrl}/v1/messages/${encodeURIComponent(options.messageId)}/reactions`, {
-            method: "POST",
-            headers: this.authHeaders({ "Content-Type": "application/json" }),
-            body: JSON.stringify({
-                operation: options.operation,
-                type: options.type,
-                ...(options.emoji ? { emoji: options.emoji } : {}),
-                ...(options.partIndex !== undefined
-                    ? { part_index: options.partIndex }
-                    : {}),
-            }),
-        });
-        await raiseForStatus(response);
-    }
-    /**
-     * `POST /v1/conversations/{id}/typing`. Ephemeral: pushed to live devices,
-     * never entering the event log. Relay also exposes `/responding`, which
-     * commits a Read receipt before it starts typing; this adapter keeps the two
-     * apart so `markAsRead` stays the only call that moves a watermark.
-     */
-    async typing(options) {
-        const response = await this.fetchImpl(`${this.baseUrl}/v1/conversations/${encodeURIComponent(options.conversationId)}/typing`, {
-            method: "POST",
-            headers: this.authHeaders({ "Content-Type": "application/json" }),
-            body: JSON.stringify({
-                started: options.started ?? true,
-                ...(options.label ? { label: options.label } : {}),
-                ...(options.invocationId
-                    ? { invocation_id: options.invocationId }
-                    : {}),
-            }),
-        });
-        await raiseForStatus(response);
-    }
-    /**
-     * `POST /v1/conversations/{id}/read`. Watermark semantics: everything
-     * through `messageId` is read. Older or repeated targets are no-ops.
-     */
-    async markRead(conversationId, messageId) {
-        const response = await this.fetchImpl(`${this.baseUrl}/v1/conversations/${encodeURIComponent(conversationId)}/read`, {
-            method: "POST",
-            headers: this.authHeaders({ "Content-Type": "application/json" }),
-            body: JSON.stringify({ message_id: messageId }),
-        });
-        await raiseForStatus(response);
-    }
-    /** `GET /v1/conversations/{id}/messages`, newest first. */
-    async history(options) {
-        const query = new URLSearchParams();
-        if (options.limit !== undefined)
-            query.set("limit", String(options.limit));
-        if (options.beforeSequence !== undefined) {
-            query.set("before_sequence", String(options.beforeSequence));
-        }
-        const suffix = query.size > 0 ? `?${query}` : "";
-        return this.json(`/v1/conversations/${encodeURIComponent(options.conversationId)}/messages${suffix}`, { method: "GET" });
-    }
-    /** `GET /v1/conversations/{id}`. */
-    async conversation(conversationId) {
-        return this.json(`/v1/conversations/${encodeURIComponent(conversationId)}`, { method: "GET" });
-    }
-    /**
-     * `GET /v1/users/{id}`. Scoped: the user must currently share an active
-     * conversation with this agent, so an unknown id answers 404 rather than
-     * confirming that an account exists.
-     */
-    async user(userId) {
-        return this.json(`/v1/users/${encodeURIComponent(userId)}`, { method: "GET" });
-    }
-    /**
-     * `POST /v1/attachments`. One raw body, `Content-Length` required and
-     * verified against the stored object. Used for Chat SDK file uploads and for
-     * attachments that arrive as bytes rather than a public URL.
-     */
-    async upload(options) {
-        const headers = {
-            "Content-Length": String(options.body.byteLength),
-            "Content-Type": options.contentType ?? "application/octet-stream",
-        };
-        if (options.filename)
-            headers["X-Relay-Filename"] = options.filename;
-        const body = options.body.slice().buffer;
-        const result = await this.json("/v1/attachments", { method: "POST", headers, body });
-        return result.attachment;
-    }
-}

package/dist/src/format.d.ts

@@ -1,43 +0,0 @@
-import type { Root } from "chat";
-import type { RelayStyleRange } from "./types.js";
-/**
- * Relay does not render Markdown. A text part carries canonical plain text
- * plus optional `styles` runs, offsets in UTF-16 code units, and clients draw
- * the runs. So the conversion from the Chat SDK's mdast is not a stringify: it
- * flattens the tree to the text a person reads and records the emphasis it
- * carried as style ranges, which is the only path that keeps both the words
- * and the formatting.
- *
- * Constructs Relay has no style for keep their information in the text rather
- * than losing it: a link whose label differs from its target renders as
- * `label (url)`, a blockquote keeps a `> ` line prefix, and a table is drawn as
- * a monospace ASCII grid.
- */
-export interface RenderedText {
-    text: string;
-    styles: RelayStyleRange[];
-}
-/** Relay accepts at most 200 style ranges on one text part. */
-export declare const MAX_STYLE_RANGES = 200;
-/**
- * Collapse the raw run list into what Relay's contract requires: sorted by
- * start, non-overlapping, and no more than 200 entries. Nested emphasis
- * produces overlapping runs, so they are flattened onto a per-character style
- * set and then re-run-length-encoded.
- */
-export declare function normalizeStyles(runs: RelayStyleRange[]): RelayStyleRange[];
-/**
- * Insert a prefix at the start of every line, remapping style offsets so the
- * runs still cover the same characters.
- */
-export declare function prefixLines(rendered: RenderedText, prefix: string, firstPrefix?: string): RenderedText;
-/** Flatten an mdast tree into Relay text plus style runs. */
-export declare function renderAst(ast: Root): RenderedText;
-/** Flatten a Markdown string into Relay text plus style runs. */
-export declare function renderMarkdown(markdown: string): RenderedText;
-/**
- * Text a caller supplied verbatim. The empty `styles` array is meaningful to
- * Relay: it marks the part as structured plain text so no client tries to read
- * it as a legacy Markdown body.
- */
-export declare function renderRawText(value: string): RenderedText;