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

package/LICENSE

@@ -5,9 +5,9 @@ Copyright (c) 2026 Companion Inc.
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.

package/README.md

@@ -1,10 +1,23 @@
 # @relaymessenger/chat-sdk-adapter
 
-Relay adapter for the [Vercel Chat SDK](https://chat-sdk.dev). Relay is a
-consumer messenger where people talk to agents the way they talk to contacts;
-this package makes a Relay conversation a Chat SDK thread, so anything built on
-the Chat SDK can reach Relay users. Raw HTTPS remains the canonical contract;
-this is a thin, dependency-free binding of it.
+Vendor-official Relay adapter for
+[Vercel Chat SDK](https://chat-sdk.dev), targeting `chat@4.39.0`.
+
+Source is maintained in
+[`RelayMessenger/Relay-SDK`](https://github.com/RelayMessenger/Relay-SDK/tree/main/packages/chat-sdk-adapter)
+under `packages/chat-sdk-adapter`.
+
+Relay Chats map one-to-one to Chat SDK threads. Provider thread IDs are stable
+`relay:<chat UUID>` values; provider message IDs are bare Relay Message UUIDs.
+
+## Install
+
+```sh
+npm install chat@4.39.0 @chat-adapter/state-memory@4.39.0 \
+  @relaymessenger/chat-sdk-adapter
+```
+
+## Minimal use
 
 ```ts
 import { createMemoryState } from "@chat-adapter/state-memory";
@@ -12,11 +25,11 @@ import { createRelayAdapter } from "@relaymessenger/chat-sdk-adapter";
 import { Chat } from "chat";
 
 const chat = new Chat({
-  userName: "My Agent",
+  userName: "My Relay Agent",
   adapters: {
     relay: createRelayAdapter({
-      token: process.env.RELAY_AGENT_TOKEN!,
-      webhookSecret: process.env.RELAY_WEBHOOK_SECRET!,
+      token: process.env.RELAY_AGENT_TOKEN,
+      webhookSecret: process.env.RELAY_WEBHOOK_SECRET,
     }),
   },
   state: createMemoryState(),
@@ -24,98 +37,205 @@ const chat = new Chat({
 
 chat.onNewMention(async (thread, message) => {
   await thread.subscribe();
-  await thread.post({ markdown: `You said: ${message.text}` });
+  await thread.post(`You said: ${message.text}`);
 });
 
-// Mount as a POST route.
+// Mount this on the Relay webhook URL.
 export const POST = (request: Request) => chat.webhooks.relay(request);
 ```
 
-`chat` is a peer dependency: install it alongside this package.
-
-## With eve
-
-eve's Chat SDK channel bridges any adapter to an agent. See
-[`examples/eve`](../../examples/eve) in this repository for the channel file and
-the environment it needs.
-
-## What the adapter enforces
-
-- Standard Webhooks signature verification over the exact raw body, then
-  `event_id` deduplication, because Relay delivers at least once. The event id
-  is claimed before the handler runs, so two redeliveries racing each other
-  cannot both dispatch, and released again if the handler throws, so Relay's
-  retry of a failed turn is still handled. **This window is a bounded set in
-  memory, in one process.** A restart, or a second instance behind the same
-  webhook URL, has no claim to lose and will dispatch the event again. The
-  idempotency key below is what makes that second dispatch harmless.
-- A deterministic `Idempotency-Key` on every `POST /v1/messages`, derived from
-  the inbound event id and the send's position in the turn, and from nothing
-  else. Relay hashes the request body server side and stores it beside the key,
-  so a retry carrying the same body replays the first response and a retry
-  carrying a different body is refused with 409 `idempotency_conflict`. Keeping
-  the content out of the key is what leaves both of those reachable: a key that
-  moved with the body would make every retry a new send, and a handler backed
-  by a model rarely writes the same words twice.
-- Group `invocation_id` threading. Relay delivers a group message to an agent
-  only when that agent was invoked, and the reply is scoped to that single-use
-  invocation, so the first send of a turn carries it and a second raises
-  `RelayInvocationSpentError` rather than going out bare and taking a 403.
-- Chunking rather than truncation. Relay caps a text part at 8 KB and a message
-  at 32 parts; a longer reply becomes more parts, and then more messages. Each
-  text part draws as its own balloon in the app, so a long reply arrives as a
-  stack of bubbles rather than one tall one. A split consumes the whitespace it
-  lands on, and nothing else.
-
-## Formatting
-
-Relay does not render Markdown. A text part carries canonical plain text plus
-`styles` runs with UTF-16 offsets, and clients draw the runs. So `{ markdown }`
-and `{ ast }` are flattened to the text a person reads, with emphasis carried
-across as style ranges: `strong` becomes `bold`, `emphasis` becomes `italic`,
-`delete` becomes `strikethrough`, and inline or fenced code becomes `monospace`.
-
-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 its `> ` line prefix, a list keeps its markers, and a table is
-drawn as a monospace ASCII grid. A plain string is sent verbatim with an empty
-`styles` array, which is Relay's marker for structured plain text rather than a
-legacy Markdown body.
-
-## Capabilities
-
-| Chat SDK operation                | Relay                                                            |
-| --------------------------------- | ---------------------------------------------------------------- |
-| `postMessage`, `editMessage`, `deleteMessage` | `POST /v1/messages`, `PATCH` and `DELETE /v1/messages/{id}` |
-| `addReaction`, `removeReaction`    | `POST /v1/messages/{id}/reactions`                              |
-| `startTyping`                      | `POST /v1/conversations/{id}/typing`, ephemeral, 80-char label  |
-| `markAsRead`                       | `POST /v1/conversations/{id}/read`                              |
-| `fetchMessages`, `fetchThread`     | `GET /v1/conversations/{id}/messages` and `/v1/conversations/{id}` |
-| `getUser`                          | `GET /v1/users/{id}`, scoped to a shared conversation           |
-| `stream`                           | Buffered, then committed as one message                          |
-
-Things Relay does not do, stated rather than faked:
-
-- **No streaming bubbles.** A turn commits exactly one canonical message, so
-  `stream` buffers the whole reply and posts it once. Nothing partial reaches a
-  recipient. With eve's Chat SDK channel, set `streaming: false`.
-- **No forward history cursor.** `GET /v1/conversations/{id}/messages` pages
-  backwards with `before_sequence`, so `fetchMessages({ direction: "forward" })`
-  throws `NotImplementedError` instead of walking the whole conversation.
-- **No agent-initiated DM.** `POST /v1/conversations/direct` accepts a user
-  session, not an Agent Token, so `openDM` is not implemented. A conversation
-  starts when a person adds the agent.
-- **No single-message read.** The API has no `GET /v1/messages/{id}`, so
-  `fetchMessage` is not implemented and the Chat SDK returns `null`.
-- **No cards.** Relay removed interactive components. A card is delivered as its
-  fallback text, so the words arrive but buttons do not render and a
-  human-in-the-loop prompt cannot be answered in the app.
-- **No edits carrying media.** Relay requires an edit to stay text-bearing and
-  rejects attachment parts.
-
-Attachments work in both directions. Inbound media and voice memo parts arrive as
-Chat SDK attachments; outbound attachments with a public HTTPS URL are sent as
-media parts, and outbound bytes are uploaded through `POST /v1/attachments`
-first.
-
-Docs: <https://docs.relayapp.im>.
+An executable Node HTTP example is in [`examples/server.mjs`](examples/server.mjs).
+
+## Factory API
+
+```ts
+type RelayCredential =
+  | string
+  | (() => string | Promise<string>);
+
+interface RelayAdapterOptions {
+  token?: RelayCredential;          // RELAY_AGENT_TOKEN fallback
+  webhookSecret?: RelayCredential;  // RELAY_WEBHOOK_SECRET fallback
+  typing?: boolean;                 // default true
+  userName?: string;                // default "Relay Agent"
+  agentId?: string;                 // this agent's Relay Contact UUID
+  baseUrl?: string;                 // default https://api.relayapp.im
+  fetch?: typeof fetch;
+  client?: RelayClient;
+  signatureToleranceSeconds?: number; // default 300
+  idempotencyKeyResolver?: (context: {
+    chatId: string;
+    threadId: string;
+    parts: readonly RelayOutgoingPart[];
+    replyToMessageId?: string;
+  }) => string | Promise<string>;
+}
+
+createRelayAdapter(options?: RelayAdapterOptions): RelayAdapter;
+```
+
+Credential functions satisfy Vercel's vendor-official non-static credential
+requirement. The token resolver is called for every Relay API request. The
+webhook-secret resolver is called for every webhook delivery. Values are not
+cached.
+
+Every send caused by an inbound webhook carries
+`Idempotency-Key: relay-chat-sdk:<event_id>:<send ordinal>`. A redelivery starts
+at ordinal zero again, so the same event/body replays while changed recovery
+content reaches Relay under the same key and receives the contract's 409
+`idempotency_conflict`. This context uses `AsyncLocalStorage` only for the
+active turn and is never persisted.
+
+Posts made outside an inbound webhook have no Relay `event_id`. The adapter
+therefore requires `idempotencyKeyResolver` for those non-empty posts rather
+than manufacturing a random key that changes on recovery. Think integrations
+should return their stable Action/delivery identity from this resolver.
+
+### Think runtime typing
+
+For a runtime that owns typing timing, disable Chat SDK surface typing:
+
+```ts
+const relay = createRelayAdapter({
+  token,
+  webhookSecret,
+  typing: false,
+});
+```
+
+With `typing: false`, both `startTyping()` and `endTyping()` validate the thread
+ID but make no Relay request. This prevents Think's pre-inference
+`ChatThread.startTyping()` from surfacing. Other adapter instances default to
+normal `POST`/`DELETE /v1/chats/{chatId}/typing` support.
+
+## Locked contract
+
+This package was rewritten against:
+
+- Relay Server `9b4d5bb32cc749c6fd271969948c385300d404d6`
+- OpenAPI SHA-256
+  `f62f431fc0daa48500926bf87753f81c3fdda25ab463b130ca97f2896367e0a5`
+- Relay API `v1`
+- Relay webhook payload version `2026-08-30`
+- `chat@4.39.0`
+
+The exact OpenAPI snapshot is retained under `contracts/` for reproducible
+contract tests and is excluded from the npm package.
+
+## Supported surface
+
+| Chat SDK operation | Locked Relay v1 operation |
+| --- | --- |
+| `postMessage`, `postChannelMessage` | `POST /v1/chats/{chatId}/messages` |
+| `reply` | Same route with `message.reply_to` |
+| `stream` | Buffered, then one canonical Message; never partial bubbles |
+| outbound public-URL media | Message `media` part |
+| outbound bytes/files | Explicitly allocate/upload with `@relaymessenger/sdk`, then post a stable public HTTPS URL |
+| inbound media | Chat SDK `Attachment` with `fetchData()` |
+| `addReaction`, `removeReaction` | `POST /v1/messages/{messageId}/reactions` |
+| `startTyping`, `endTyping` | `POST`/`DELETE /v1/chats/{chatId}/typing` |
+| `markAsRead` | `POST /v1/chats/{chatId}/read` |
+| `fetchMessages({ direction: "forward" })` | `GET /v1/chats/{chatId}/messages` |
+| `fetchMessage` | `GET /v1/messages/{messageId}` |
+| `fetchThread`, `fetchChannelInfo` | `GET /v1/chats/{chatId}` |
+
+### Inbound attachments
+
+An inbound Relay media part becomes a Chat SDK `Attachment` carrying
+`url`, `mimeType`, `name`, `size`, `type`, `width`, `height`, and a
+`fetchData()` that resolves to the bytes as an `ArrayBuffer`. Nothing is
+downloaded until you call it.
+
+```ts
+for (const attachment of message.attachments) {
+  const bytes = await attachment.fetchData?.();
+}
+```
+
+**A Relay download URL expires 60 minutes after Relay minted it.** The URL is a
+sealed, unauthenticated download capability, so `fetchData()` sends no Agent
+Token; after that window the download fails with `RelayApiError` HTTP 404.
+
+That expiry is not a limit on queued work. `Message.toJSON()` drops
+`fetchData`, so queue and debounce strategies call `rehydrateAttachment()` to
+rebuild it — and the rebuilt closure calls `GET /v1/attachments/{attachmentId}`
+first, which mints a new 60-minute download link on every request. A Message may
+sit in a queue for as long as you like and still read its bytes. The serialized
+URL is kept in `fetchMetadata` only as the fallback for an attachment whose
+metadata predates this behavior.
+
+`GET /v1/attachments/{attachmentId}` authorizes any Chat participant who could
+read the Message, so an agent reads the attachments of messages sent to it
+without owning them.
+
+Relay text parts are plain text and are limited to 10,000 UTF-16 code units.
+Long Chat SDK text is split without breaking surrogate pairs. A Relay Message
+is limited to 100 parts. A public HTTPS attachment URL is sent directly.
+Automatic byte/file uploads are rejected because a fresh Attachment allocation
+would change the Message body after an ambiguous send. Allocate and upload with
+`@relaymessenger/sdk`, retain that prepared identity durably, then give this
+adapter the stable HTTPS URL.
+
+Think's `thread.post(callback.stream())` path is safe when the stream is empty:
+the adapter returns a local no-op result so Chat SDK does not enter its
+post-then-edit fallback. Non-empty streams are fully buffered and committed in
+one request. Empty string posts are the same no-op. No partial or placeholder
+Message reaches Relay.
+
+## Explicitly unsupported
+
+The adapter throws Chat SDK `NotImplementedError` rather than calling an
+undocumented route for:
+
+- message editing and deletion;
+- editable drafts or partial streaming bubbles;
+- open-only direct messages;
+- public Contact lookup;
+- backward history pagination.
+
+Relay's locked chat-history cursor advances oldest-to-newest. It cannot satisfy
+Chat SDK's backward-cursor semantics, so callers must request
+`direction: "forward"` explicitly.
+
+Cards have no Relay interaction surface. Their fallback text is sent; a card
+without text is rejected.
+
+## Webhooks
+
+The adapter internally verifies current signed Standard Webhooks over the exact
+raw body:
+
+```text
+HMAC-SHA256(secret, "${webhook-id}.${webhook-timestamp}.${rawBody}")
+```
+
+Every valid current event type is acknowledged. `message.received` is
+dispatched to Chat SDK message handlers, and non-self `reaction.added` /
+`reaction.removed` events are dispatched to reaction handlers. Receipt,
+participant, Chat metadata, typing, and Contact events have no matching Chat
+SDK inbound hook and are acknowledged without fabricated behavior.
+
+Direct Chats route through Chat SDK's direct-message path and do not need an
+`isMention` flag. In a group, `isMention` is true only when a canonical text
+part's `mention` equals the receiving Chat `owner_handle`; when `agentId` is
+configured, the owner UUID must match it.
+
+This package adds no persistence and no adapter-owned delivery-idempotency
+store. Think Actions remain the delivery-idempotency owner outside webhook
+turns. `RelayClient.sendMessage()` requires an explicit idempotency key.
+
+## Development
+
+```sh
+npm ci
+npm run check
+npm run build
+npm run test:unit
+npm run test:workerd
+npm run test:installed
+```
+
+`@chat-adapter/shared@4.39.0` provides shared adapter utilities and errors. That
+published package has no `/tests` export; Vercel's published contract runner is
+`@chat-adapter/tests@4.39.0`, which this package uses alongside
+`@chat-adapter/shared`.

package/dist/adapter.d.ts

@@ -0,0 +1,156 @@
+import { Message, type Adapter, type AdapterPostableMessage, type Attachment, type ChatInstance, type EmojiValue, type FetchOptions, type FetchResult, type FormattedContent, type RawMessage, type StreamChunk, type ThreadInfo, type UserInfo, type WebhookOptions } from "chat";
+import { RelayClient } from "./client.js";
+import type { RelayClientOptions } from "./client.js";
+import { type RelayCredential } from "./credentials.js";
+import type { RelayRawMessage, RelayThreadId } from "./types.js";
+export declare const RELAY_ADAPTER_NAME = "relay";
+export interface RelayIdempotencyKeyContext {
+    chatId: string;
+    parts: ReadonlyArray<import("./types.js").RelayOutgoingPart>;
+    replyToMessageId?: string;
+    threadId: string;
+}
+export type RelayIdempotencyKeyResolver = (context: RelayIdempotencyKeyContext) => string | Promise<string>;
+export interface RelayAdapterOptions extends Omit<RelayClientOptions, "token"> {
+    /**
+     * Relay Agent Token or per-call resolver.
+     * Defaults to `RELAY_AGENT_TOKEN`.
+     */
+    token?: RelayCredential;
+    /**
+     * Standard Webhooks signing secret or per-delivery resolver.
+     * Defaults to `RELAY_WEBHOOK_SECRET`.
+     */
+    webhookSecret?: RelayCredential;
+    /**
+     * Disable Chat SDK surface typing for runtimes that own typing UX.
+     * Defaults to true.
+     */
+    typing?: boolean;
+    /** Display name shown to Chat SDK handlers. */
+    userName?: string;
+    /** This Relay agent Contact UUID, when known. */
+    agentId?: string;
+    /** Standard Webhooks timestamp tolerance in seconds. */
+    signatureToleranceSeconds?: number;
+    /**
+     * Stable key source for posts made outside an inbound webhook turn.
+     * Inbound turns always derive keys from event_id plus send ordinal.
+     */
+    idempotencyKeyResolver?: RelayIdempotencyKeyResolver;
+    /** Controlled client injection for tests and custom transports. */
+    client?: RelayClient;
+}
+/**
+ * Relay adapter for `chat@4.39.0`, limited to the locked public v1 contract.
+ */
+export declare class RelayAdapter implements Adapter<RelayThreadId, RelayRawMessage> {
+    readonly name = "relay";
+    readonly userName: string;
+    readonly botUserId?: string;
+    readonly lockScope: "thread";
+    readonly persistThreadHistory = false;
+    readonly typing: boolean;
+    readonly client: RelayClient;
+    private readonly signatureToleranceSeconds?;
+    private readonly webhookSecret;
+    private readonly idempotencyKeyResolver;
+    private readonly turns;
+    /**
+     * Request-scoped Chat kind hints. Entries exist only while an inbound
+     * dispatch is active; this is not persistence or a delivery-idempotency
+     * store.
+     */
+    private readonly activeChatKinds;
+    private chat?;
+    constructor(options?: RelayAdapterOptions);
+    initialize(chat: ChatInstance): Promise<void>;
+    encodeThreadId(data: RelayThreadId): string;
+    decodeThreadId(threadId: string): RelayThreadId;
+    channelIdFromThreadId(threadId: string): string;
+    renderFormatted(content: FormattedContent): string;
+    /**
+     * Build the Chat SDK `fetchData` closure for one Relay media part.
+     *
+     * The download runs through this adapter's own Relay client, so a consumer
+     * supplied `fetch` (Workers, a proxy, a test double) serves attachment bytes
+     * exactly as it serves every other Relay call.
+     */
+    private attachmentData;
+    /**
+     * Mint a replacement download URL for an attachment id.
+     *
+     * Returns `undefined` when the call cannot produce one and the caller still
+     * holds a fallback URL; rethrows when there is nothing to fall back to, so a
+     * genuine authorization or not-found failure is never swallowed.
+     */
+    private freshDownloadUrl;
+    /**
+     * Build the `fetchData` closure for an attachment that survived a queue.
+     *
+     * The stored URL may already have expired, so the id is tried first: Relay
+     * mints a new download link on every `GET /v1/attachments/{attachmentId}`.
+     * The serialized URL is the fallback for the one case the id cannot cover —
+     * an attachment whose `fetchMetadata` predates this adapter version.
+     */
+    private rehydratedAttachmentData;
+    /**
+     * Rebuild `fetchData` on an attachment that survived serialization.
+     *
+     * `Message.toJSON()` drops `data` and `fetchData`, so Chat SDK calls this
+     * when a queue or debounce strategy rehydrates a Message. A Relay download
+     * URL expires 60 minutes after Relay minted it, and a queue can hold a
+     * Message for longer, so this re-mints from `fetchMetadata.attachmentId` and
+     * falls back to the stored URL only when the id call cannot serve one.
+     */
+    rehydrateAttachment(attachment: Attachment): Attachment;
+    parseMessage(raw: RelayRawMessage): Message<RelayRawMessage>;
+    private unsupported;
+    private send;
+    private sendInTurn;
+    private resolveExternalIdempotencyKey;
+    private noopResult;
+    private isMentioned;
+    private enterChatKind;
+    /**
+     * Chat SDK asks synchronously while dispatching. Relay's stable thread ID
+     * intentionally contains only the Chat UUID, so the direct/group hint is
+     * scoped to the active webhook dispatch and never persisted.
+     */
+    isDM(threadId: string): boolean;
+    postMessage(threadId: string, message: AdapterPostableMessage): Promise<RawMessage<RelayRawMessage>>;
+    postChannelMessage(channelId: string, message: AdapterPostableMessage): Promise<RawMessage<RelayRawMessage>>;
+    reply(threadId: string, messageId: string, message: AdapterPostableMessage): Promise<RawMessage<RelayRawMessage>>;
+    editMessage(threadId: string, messageId: string, _message: AdapterPostableMessage): Promise<RawMessage<RelayRawMessage>>;
+    deleteMessage(threadId: string, messageId: string): Promise<void>;
+    addReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
+    removeReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
+    startTyping(threadId: string): Promise<void>;
+    endTyping(threadId: string): Promise<void>;
+    markAsRead(threadId: string, messageId: string): Promise<void>;
+    /**
+     * Relay's public chat cursor advances oldest-to-newest. Chat SDK's backward
+     * cursor contract cannot be represented, so only explicit forward reads are
+     * supported rather than faking backward pagination.
+     */
+    fetchMessages(threadId: string, options?: FetchOptions): Promise<FetchResult<RelayRawMessage>>;
+    fetchChannelMessages(channelId: string, options?: FetchOptions): Promise<FetchResult<RelayRawMessage>>;
+    fetchMessage(threadId: string, messageId: string): Promise<Message<RelayRawMessage> | null>;
+    fetchThread(threadId: string): Promise<ThreadInfo>;
+    fetchChannelInfo(channelId: string): Promise<{
+        channelVisibility: import("chat").ChannelVisibility | undefined;
+        id: string;
+        isDM: boolean | undefined;
+        metadata: Record<string, unknown>;
+        name?: string | undefined;
+    }>;
+    getChannelVisibility(): "private";
+    getUser(_userId: string): Promise<UserInfo | null>;
+    openDM(_userId: string): Promise<string>;
+    stream(threadId: string, stream: AsyncIterable<string | StreamChunk>): Promise<RawMessage<RelayRawMessage> | null>;
+    handleWebhook(request: Request, options?: WebhookOptions): Promise<Response>;
+    private initializedChat;
+    private dispatch;
+}
+export declare function createRelayAdapter(options?: RelayAdapterOptions): RelayAdapter;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

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