r2-relay-channel 0.3.5

package/dist/runtime.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import os from "node:os";
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+import { PLUGIN_ID } from "./config.js";
+const { setRuntime: setRelayRuntime, getRuntime: getRelayRuntime } = createPluginRuntimeStore("R2 Relay runtime not initialized");
+let relayConfig = null;
+let relayStateDir = null;
+let persistedServerId = null;
+function setRelayConfig(cfg) {
+    relayConfig = cfg;
+}
+function getRelayConfig() {
+    if (!relayConfig) {
+        throw new Error("R2 Relay config not initialized");
+    }
+    return relayConfig;
+}
+function setRelayStateDir(stateDir) {
+    relayStateDir = stateDir;
+}
+function resolveFallbackStateDir() {
+    const fromEnv = process.env.OPENCLAW_STATE_DIR?.trim();
+    if (fromEnv) {
+        return fromEnv;
+    }
+    return path.join(os.homedir(), ".openclaw");
+}
+function resolvePluginStateDir() {
+    const baseStateDir = relayStateDir ?? resolveFallbackStateDir();
+    return path.join(baseStateDir, "plugins", PLUGIN_ID);
+}
+function getPersistedRelayServerId() {
+    if (persistedServerId) {
+        return persistedServerId;
+    }
+    const dir = resolvePluginStateDir();
+    const file = path.join(dir, "server-id.txt");
+    try {
+        const existing = fs.readFileSync(file, "utf8").trim();
+        if (existing) {
+            persistedServerId = existing;
+            return existing;
+        }
+    }
+    catch { }
+    fs.mkdirSync(dir, { recursive: true });
+    const generated = `srv-${crypto.randomUUID().replace(/-/g, "").slice(0, 12)}`;
+    fs.writeFileSync(file, `${generated}\n`, "utf8");
+    persistedServerId = generated;
+    return generated;
+}
+export { getPersistedRelayServerId, getRelayConfig, getRelayRuntime, resolvePluginStateDir, setRelayConfig, setRelayRuntime, setRelayStateDir };

package/dist/service.d.ts

@@ -0,0 +1,51 @@
+import { type HeadDoc, type IdentityDoc, type InboxBatch, type RelayMessage, type RelayRetentionConfig, type SendMessageOptions, type SendMessageResult, type SweepRuleSummary } from "./relay-core/index.js";
+import { R2Relay } from "./protocol.js";
+import { R2Client } from "./r2client.js";
+export declare const IDENTITY_REFRESH_INTERVAL_MS: number;
+export declare const RELAY_PLUGIN_VERSION: string;
+export interface ServiceConfig {
+    endpoint: string;
+    bucket: string;
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    forcePathStyle?: boolean;
+    peerId: string;
+}
+export interface InboxMessage {
+    key: string;
+    message: RelayMessage;
+}
+export declare class Service {
+    readonly client: R2Client;
+    readonly relay: R2Relay;
+    readonly cfg: ServiceConfig;
+    private readonly transport;
+    constructor(cfg: ServiceConfig);
+    getPresignedUrl(key: string, expiresIn: number): Promise<string>;
+    getAttachmentObject(key: string): Promise<import("@aws-sdk/client-s3").GetObjectCommandOutput | null>;
+    publishIdentity(identity?: Partial<IdentityDoc>): Promise<IdentityDoc>;
+    publishIdentify(identity?: Partial<IdentityDoc>): Promise<IdentityDoc>;
+    getIdentity(peer: string): Promise<IdentityDoc | null>;
+    sendMessage(to: string, options: SendMessageOptions): Promise<SendMessageResult>;
+    sendStreamingSnapshots(to: string, snapshots: string[], options: Omit<SendMessageOptions, "delivery">): Promise<{
+        streamId: string;
+        results: SendMessageResult[];
+    }>;
+    getHead(peer: string): Promise<HeadDoc | null>;
+    getHeadState(peer: string): Promise<{
+        doc: HeadDoc;
+        etag: string | null;
+    } | null>;
+    readMessage(key: string): Promise<RelayMessage | null>;
+    markMessageProcessed(key: string, patch: {
+        processedAt?: number;
+        processedBy?: string | null;
+        state?: "pending" | "processing" | "done" | "error";
+        error?: string | null;
+    }): Promise<RelayMessage | null>;
+    collectInboxMessages(selfId: string, lastSeenKey: string | null): Promise<InboxBatch>;
+    sweepByKeyTimestamp(prefix: string, ttlDays: number, abortSignal?: AbortSignal): Promise<SweepRuleSummary>;
+    sweepRetention(ttl: RelayRetentionConfig, abortSignal?: AbortSignal): Promise<SweepRuleSummary[]>;
+    pollInbox(selfId: string, handler: (msg: RelayMessage, key: string) => Promise<void>, pollIntervalMs?: number, backoffMax?: number, deleteAfterProcessing?: boolean, abortSignal?: AbortSignal): Promise<void>;
+}

package/dist/service.js

@@ -0,0 +1,186 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { PreconditionFailedError, R2RelayTransport, } from "./relay-core/index.js";
+import { R2Relay } from "./protocol.js";
+import { R2Client } from "./r2client.js";
+export const IDENTITY_REFRESH_INTERVAL_MS = 12 * 60 * 60 * 1000;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function resolvePluginVersion() {
+    try {
+        const pkgPath = path.join(__dirname, "..", "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        const version = pkg.version?.trim();
+        return version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export const RELAY_PLUGIN_VERSION = resolvePluginVersion();
+class R2ObjectStoreAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async putObject(key, body, contentType, tagging, ifMatch, ifNoneMatch) {
+        try {
+            return await this.client.putObject(key, body, contentType, tagging, ifMatch, ifNoneMatch);
+        }
+        catch (err) {
+            const value = err;
+            if (value?.code === "PreconditionFailed") {
+                throw new PreconditionFailedError();
+            }
+            throw err;
+        }
+    }
+    async getObject(key) {
+        return await this.client.getObject(key);
+    }
+    async getJsonWithEtag(key) {
+        return await this.client.getJsonWithEtag(key);
+    }
+    async deleteObject(key) {
+        return await this.client.deleteObject(key);
+    }
+    async deleteObjects(keys) {
+        return await this.client.deleteObjects(keys);
+    }
+    async listPrefixPage(prefix, continuationToken, maxKeys) {
+        return await this.client.listPrefixPage(prefix, continuationToken, maxKeys);
+    }
+}
+async function streamToUtf8(stream) {
+    if (typeof stream === "string") {
+        return stream;
+    }
+    if (!stream) {
+        return "";
+    }
+    const body = stream;
+    if (typeof body.transformToString === "function") {
+        return await body.transformToString();
+    }
+    if (typeof body[Symbol.asyncIterator] === "function") {
+        const chunks = [];
+        for await (const chunk of body) {
+            chunks.push(Buffer.from(chunk));
+        }
+        return Buffer.concat(chunks).toString("utf8");
+    }
+    return String(stream);
+}
+async function sleep(ms, abortSignal) {
+    await new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        if (!abortSignal) {
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        if (abortSignal.aborted) {
+            onAbort();
+            return;
+        }
+        abortSignal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+export class Service {
+    client;
+    relay;
+    cfg;
+    transport;
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.client = new R2Client(cfg);
+        this.relay = new R2Relay({ bucket: cfg.bucket });
+        this.transport = new R2RelayTransport({
+            store: new R2ObjectStoreAdapter(this.client),
+            keyspace: this.relay,
+            peerId: cfg.peerId,
+            sleep: (ms) => sleep(ms),
+        });
+    }
+    async getPresignedUrl(key, expiresIn) {
+        return this.client.getPresignedUrl(key, expiresIn);
+    }
+    async getAttachmentObject(key) {
+        return this.client.getObject(key);
+    }
+    async publishIdentity(identity) {
+        return await this.transport.publishIdentity({
+            role: "server",
+            software: { id: "openclaw", name: "OpenClaw", version: RELAY_PLUGIN_VERSION },
+            protocol: { name: "r2-relay", version: 3 },
+            capabilities: {
+                messaging: { text: true, streaming: true, reactions: true, system_events: true },
+                conversations: { list: true, create: false, reset: false, archive: false, threading: false },
+                agents: { list: true, multiple: true, switch: true, per_agent_models: false },
+                attachments: null,
+                approvals: {
+                    exec: true,
+                    tool: false,
+                    custom: false,
+                },
+                extensions: null,
+            },
+            agents: [],
+            conversations: [],
+            limits: null,
+            ...(identity ?? {}),
+            peer: identity?.peer ?? this.cfg.peerId,
+            last_seen: identity?.last_seen ?? Date.now(),
+        });
+    }
+    async publishIdentify(identity) {
+        return await this.publishIdentity(identity);
+    }
+    async getIdentity(peer) {
+        const key = this.relay.makeIdentityKey(peer);
+        try {
+            const res = await this.client.getObject(key);
+            if (!res || typeof res !== "object" || !("Body" in res) || !res.Body) {
+                return null;
+            }
+            const body = await streamToUtf8(res.Body);
+            return JSON.parse(body);
+        }
+        catch {
+            return null;
+        }
+    }
+    async sendMessage(to, options) {
+        return await this.transport.sendMessage(to, options);
+    }
+    async sendStreamingSnapshots(to, snapshots, options) {
+        return await this.transport.sendStreamingSnapshots(to, snapshots, options);
+    }
+    async getHead(peer) {
+        return await this.transport.getHead(peer);
+    }
+    async getHeadState(peer) {
+        return await this.transport.getHeadState(peer);
+    }
+    async readMessage(key) {
+        return await this.transport.readMessage(key);
+    }
+    async markMessageProcessed(key, patch) {
+        return await this.transport.markMessageProcessed(key, patch);
+    }
+    async collectInboxMessages(selfId, lastSeenKey) {
+        return await this.transport.collectInboxMessages(selfId, lastSeenKey);
+    }
+    async sweepByKeyTimestamp(prefix, ttlDays, abortSignal) {
+        return await this.transport.sweepByKeyTimestamp(prefix, ttlDays, abortSignal);
+    }
+    async sweepRetention(ttl, abortSignal) {
+        return await this.transport.sweepRetention(ttl, abortSignal);
+    }
+    async pollInbox(selfId, handler, pollIntervalMs = 5000, backoffMax = 40000, deleteAfterProcessing = true, abortSignal) {
+        return await this.transport.pollInbox(selfId, handler, pollIntervalMs, backoffMax, deleteAfterProcessing, abortSignal);
+    }
+}

package/dist/service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/service.test.js

@@ -0,0 +1,27 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Service } from "./service.js";
+test("service sweepRetention delegates retention ownership to shared transport core", async () => {
+    const service = new Service({
+        endpoint: "https://example.r2.cloudflarestorage.com",
+        bucket: "relay-bucket",
+        peerId: "relay.openclaw.dev",
+    });
+    const expected = [
+        { prefix: "msg/", scanned: 2, deleted: 1 },
+        { prefix: "identity/", scanned: 1, deleted: 1 },
+    ];
+    const calls = [];
+    Object.defineProperty(service, "transport", {
+        value: {
+            sweepRetention: async (ttl, abortSignal) => {
+                calls.push({ ttl, aborted: abortSignal?.aborted ?? false });
+                return expected;
+            },
+        },
+    });
+    const ttl = { msg: 7, identity: 1 };
+    const summaries = await service.sweepRetention(ttl);
+    assert.deepEqual(summaries, expected);
+    assert.deepEqual(calls, [{ ttl, aborted: false }]);
+});

package/dist/session-publication.d.ts

@@ -0,0 +1,7 @@
+import { Service } from "./service.js";
+import type { ResolvedR2RelayAccount } from "./config.js";
+import type { ConversationDescriptor } from "./protocol.js";
+export declare function syncPublishedIdentity(service: Service, account: ResolvedR2RelayAccount, force?: boolean): Promise<void>;
+export declare function schedulePublishedIdentityRefresh(service: Service, account: ResolvedR2RelayAccount, delayMs?: number): void;
+export declare function agentIdFromSessionKey(sessionKey: string): string;
+export declare function readPublishedConversationEntry(sessionKey: string): Promise<ConversationDescriptor | null>;

package/dist/session-publication.js

@@ -0,0 +1,365 @@
+import fs from "node:fs/promises";
+import { maxBytesForKind } from "openclaw/plugin-sdk/media-runtime";
+import { getRelayConfig, getRelayRuntime } from "./runtime.js";
+import { IDENTITY_REFRESH_INTERVAL_MS, RELAY_PLUGIN_VERSION } from "./service.js";
+const MAX_IMAGE_BYTES = maxBytesForKind("image");
+const MAX_VIDEO_BYTES = maxBytesForKind("video");
+const MAX_AUDIO_BYTES = maxBytesForKind("audio");
+const MAX_DOCUMENT_BYTES = maxBytesForKind("document");
+const publishedSessionSignatures = new Map();
+const publishedIdentityAt = new Map();
+const scheduledIdentityRefreshes = new Map();
+export async function syncPublishedIdentity(service, account, force = false) {
+    const { agents, conversations } = await collectPublishedConversations(account);
+    const modelCapabilities = await collectPublishedModelCapabilities(account);
+    const signature = JSON.stringify({ agents, conversations, modelCapabilities });
+    const previousSignature = publishedSessionSignatures.get(account.accountId);
+    const now = Date.now();
+    const lastPublishedAt = publishedIdentityAt.get(account.accountId) ?? 0;
+    const heartbeatDue = now - lastPublishedAt >= IDENTITY_REFRESH_INTERVAL_MS;
+    if (previousSignature === signature && !heartbeatDue) {
+        return;
+    }
+    await service.publishIdentity({
+        peer: account.serverId,
+        display_name: deriveGatewayDisplayName(account.serverId),
+        role: "server",
+        last_seen: now,
+        protocol: { name: "r2-relay", version: 3 },
+        software: { id: "openclaw", name: "OpenClaw", version: RELAY_PLUGIN_VERSION },
+        capabilities: {
+            messaging: { text: true, streaming: true, reactions: true, system_events: true },
+            conversations: { list: true, create: false, reset: false, archive: false, threading: false },
+            agents: { list: true, multiple: agents.length > 1, switch: true, per_agent_models: Boolean(modelCapabilities) },
+            attachments: {
+                supported: true,
+                kinds: ["image", "video", "audio", "file", "unknown"],
+                max_bytes_by_kind: resolvePublishedAttachmentCapabilityLimits(),
+                oversize_behavior: "reject",
+            },
+            approvals: {
+                exec: true,
+                tool: false,
+                custom: false,
+            },
+            extensions: null,
+        },
+        limits: resolvePublishedServerLimits(),
+        agents: modelCapabilities
+            ? agents.map((a) => ({ ...a, models: modelCapabilities }))
+            : agents,
+        conversations,
+    });
+    publishedSessionSignatures.set(account.accountId, signature);
+    publishedIdentityAt.set(account.accountId, now);
+}
+export function schedulePublishedIdentityRefresh(service, account, delayMs = 250) {
+    const existing = scheduledIdentityRefreshes.get(account.accountId);
+    if (existing) {
+        clearTimeout(existing);
+    }
+    const timer = setTimeout(() => {
+        scheduledIdentityRefreshes.delete(account.accountId);
+        void syncPublishedIdentity(service, account).catch(() => { });
+    }, Math.max(0, delayMs));
+    scheduledIdentityRefreshes.set(account.accountId, timer);
+}
+async function collectPublishedModelCapabilities(_account) {
+    try {
+        const cfg = getRelayConfig();
+        const availableByID = new Map();
+        const addModel = (modelRef, label) => {
+            const normalized = modelRef?.trim();
+            if (!normalized) {
+                return;
+            }
+            const existing = availableByID.get(normalized);
+            availableByID.set(normalized, {
+                id: normalized,
+                label: existing?.label ?? (label?.trim() || undefined),
+                provider: normalized.includes("/") ? normalized.split("/")[0] : null,
+            });
+        };
+        const addModelConfig = (value) => {
+            if (!value) {
+                return;
+            }
+            if (typeof value === "string") {
+                addModel(value);
+                return;
+            }
+            addModel(value.primary);
+            for (const fallback of value.fallbacks ?? []) {
+                addModel(fallback);
+            }
+        };
+        for (const [key, entry] of Object.entries(cfg.agents?.defaults?.models ?? {})) {
+            const alias = entry?.alias;
+            addModel(key, typeof alias === "string" ? alias : null);
+        }
+        addModelConfig(cfg.agents?.defaults?.model);
+        for (const agent of cfg.agents?.list ?? []) {
+            addModelConfig(agent?.model);
+            addModelConfig(agent?.subagents?.model);
+        }
+        const available = Array.from(availableByID.values()).sort((lhs, rhs) => lhs.id.localeCompare(rhs.id));
+        const modelConfig = cfg.agents?.defaults?.model;
+        const defaultModel = typeof modelConfig === "string"
+            ? modelConfig
+            : modelConfig && typeof modelConfig.primary === "string"
+                ? modelConfig.primary
+                : null;
+        return available.length > 0 ? { available, default: defaultModel } : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function collectPublishedConversations(_account) {
+    const configuredAgents = listConfiguredAgents();
+    const agents = configuredAgents.map((agent) => ({
+        id: agent.id,
+        display_name: agent.name ?? null,
+        description: null,
+        is_default: agent.id === "main",
+        models: null,
+        default_route: { agent_id: agent.id, conversation_id: null, instance_id: null },
+        capabilities: null,
+    }));
+    const conversations = [];
+    for (const agent of configuredAgents) {
+        const agentId = agent.id;
+        try {
+            const store = await readPublishedSessionStore(agentId);
+            for (const [sessionKey, entry] of Object.entries(store)) {
+                if (typeof sessionKey !== "string" || !sessionKey.startsWith(`agent:${agentId}:`)) {
+                    continue;
+                }
+                if (!shouldPublishIdentitySession(sessionKey)) {
+                    continue;
+                }
+                conversations.push(identityConversationDocFromEntry(sessionKey, entry));
+            }
+        }
+        catch {
+            // No session store yet for this agent.
+        }
+    }
+    return {
+        agents,
+        conversations: conversations.sort((a, b) => (b.updated_at ?? 0) - (a.updated_at ?? 0)),
+    };
+}
+function shouldPublishIdentitySession(sessionKey) {
+    const normalized = sessionKey.trim().toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    if (normalized.startsWith("cron:")) {
+        return false;
+    }
+    if (normalized.startsWith("dreaming-")) {
+        return false;
+    }
+    const parts = normalized.split(":");
+    if (parts.length >= 3 && parts[0] === "agent") {
+        const scopedKey = parts.slice(2).join(":");
+        if (scopedKey.startsWith("cron:")) {
+            return false;
+        }
+    }
+    return true;
+}
+function listConfiguredAgents() {
+    const cfg = getRelayConfig();
+    const agents = new Map([
+        ["main", { id: "main", name: cfg.agents?.main?.name ?? null }],
+    ]);
+    for (const agent of cfg.agents?.list ?? []) {
+        const id = agent?.id?.trim();
+        if (id && !agents.has(id)) {
+            agents.set(id, { id, name: agent.name ?? null });
+        }
+    }
+    return Array.from(agents.values());
+}
+export function agentIdFromSessionKey(sessionKey) {
+    const parts = sessionKey.split(":");
+    if (parts.length >= 2 && parts[0] === "agent" && parts[1]?.trim()) {
+        return parts[1].trim();
+    }
+    return "main";
+}
+function identityConversationDocFromEntry(sessionKey, entry) {
+    const agentId = agentIdFromSessionKey(sessionKey);
+    return {
+        id: sessionKey,
+        display_title: resolveConversationDisplayTitle(sessionKey, entry),
+        route: {
+            agent_id: agentId,
+            conversation_id: sessionKey,
+            instance_id: readInstanceId(entry),
+        },
+        source: conversationSourceFromEntry(sessionKey, entry),
+        updated_at: typeof entry?.updatedAt === "number" ? entry.updatedAt : null,
+    };
+}
+async function readPublishedSessionStore(agentId = "main") {
+    const storePath = getRelayRuntime().channel.session.resolveStorePath(undefined, {
+        agentId,
+    });
+    const raw = await fs.readFile(storePath, "utf8");
+    return JSON.parse(raw);
+}
+export async function readPublishedConversationEntry(sessionKey) {
+    try {
+        const store = await readPublishedSessionStore(agentIdFromSessionKey(sessionKey));
+        const entry = store[sessionKey];
+        if (!entry) {
+            return null;
+        }
+        return identityConversationDocFromEntry(sessionKey, entry);
+    }
+    catch {
+        return null;
+    }
+}
+function displayTitleFromConversationId(conversationId) {
+    const parts = conversationId.split(":");
+    if (parts[0] === "agent" && parts[1]) {
+        const remainder = parts.slice(2).join(":");
+        return remainder || parts[1];
+    }
+    return conversationId;
+}
+function resolveConversationDisplayTitle(conversationId, entry) {
+    const candidates = [
+        typeof entry?.label === "string" ? entry.label : null,
+        typeof entry?.displayName === "string" ? entry.displayName : null,
+        typeof entry?.derivedTitle === "string" ? entry.derivedTitle : null,
+    ];
+    for (const candidate of candidates) {
+        const trimmed = candidate?.trim();
+        if (trimmed) {
+            return trimmed;
+        }
+    }
+    return displayTitleFromConversationId(conversationId);
+}
+function conversationSourceFromEntry(sessionKey, entry) {
+    const parsed = parseSessionKeySource(sessionKey);
+    const peerKind = firstNonEmptyString(entry?.peerKind, parsed.peerKind);
+    const threadId = firstNonEmptyString(entry?.threadId, parsed.threadId);
+    const channel = normalizeChannelName(entry?.channel ?? parsed.channel ?? "local");
+    return {
+        channel,
+        chat_kind: normalizeChatKind(peerKind, threadId),
+        account_id: firstNonEmptyString(entry?.accountId, entry?.workspaceId, entry?.orgId),
+        account_display: firstNonEmptyString(entry?.accountDisplay, entry?.workspaceName, entry?.orgName),
+        space_id: firstNonEmptyString(entry?.spaceId, entry?.guildId, entry?.teamId),
+        space_display: firstNonEmptyString(entry?.spaceDisplay, entry?.guildName, entry?.teamName),
+        chat_id: peerKind === "direct" ? null : firstNonEmptyString(entry?.chatId, entry?.peerId, parsed.peerId),
+        chat_display: peerKind === "direct" ? null : firstNonEmptyString(entry?.chatDisplay, entry?.channelName, entry?.roomName),
+        participant_id: peerKind === "direct" ? firstNonEmptyString(entry?.participantId, entry?.peerId, parsed.peerId) : null,
+        participant_display: peerKind === "direct"
+            ? firstNonEmptyString(entry?.participantDisplay, entry?.peerDisplayName, entry?.senderName, entry?.userName)
+            : null,
+        thread_id: threadId,
+        thread_display: firstNonEmptyString(entry?.threadDisplay, entry?.threadName),
+        sharing: normalizeSharing(entry?.sharing, entry?.sharedMultiUserSession),
+    };
+}
+function readInstanceId(entry) {
+    return firstNonEmptyString(entry?.instanceId, entry?.sessionId, entry?.runtimeSessionId);
+}
+function parseSessionKeySource(sessionKey) {
+    const parts = sessionKey.split(":");
+    const scoped = parts[0] === "agent" ? parts.slice(2) : parts;
+    const threadIndex = scoped.indexOf("thread");
+    const base = threadIndex >= 0 ? scoped.slice(0, threadIndex) : scoped;
+    const threadId = threadIndex >= 0 ? scoped.slice(threadIndex + 1).join(":") || null : null;
+    return {
+        channel: base[0] ?? null,
+        peerKind: base[1] ?? null,
+        peerId: base.length > 2 ? base.slice(2).join(":") : null,
+        threadId,
+    };
+}
+function normalizeChannelName(value) {
+    const normalized = firstNonEmptyString(value) ?? "local";
+    return normalized === "r2-relay-channel" ? "r2_relay" : normalized;
+}
+function normalizeChatKind(peerKind, threadId) {
+    if (threadId) {
+        return "thread";
+    }
+    switch (peerKind) {
+        case "direct":
+        case "dm":
+        case "im":
+            return "dm";
+        case "group":
+            return "group";
+        case "channel":
+            return "channel";
+        default:
+            return null;
+    }
+}
+function normalizeSharing(value, sharedFallback) {
+    const normalized = firstNonEmptyString(value)?.toLowerCase();
+    if (normalized === "private" || normalized === "shared" || normalized === "per-user") {
+        return normalized;
+    }
+    if (sharedFallback === true) {
+        return "shared";
+    }
+    return null;
+}
+function firstNonEmptyString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function deriveGatewayDisplayName(serverId) {
+    const cfg = getRelayConfig();
+    const candidates = [
+        cfg.identity?.name,
+        cfg.agents?.main?.name,
+        cfg.assistant?.name,
+        cfg.gateway?.name,
+    ];
+    for (const candidate of candidates) {
+        const trimmed = candidate?.trim();
+        if (trimmed) {
+            return trimmed;
+        }
+    }
+    return serverId
+        .replace(/[-_.]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (ch) => ch.toUpperCase()) || "Gateway";
+}
+function resolvePublishedServerLimits() {
+    return {
+        inbound_attachment_max_bytes: {
+            image: MAX_IMAGE_BYTES,
+            video: MAX_VIDEO_BYTES,
+            audio: MAX_AUDIO_BYTES,
+            file: MAX_DOCUMENT_BYTES,
+        },
+        oversize_attachment_behavior: "reject",
+    };
+}
+function resolvePublishedAttachmentCapabilityLimits() {
+    return {
+        image: MAX_IMAGE_BYTES,
+        video: MAX_VIDEO_BYTES,
+        audio: MAX_AUDIO_BYTES,
+        file: MAX_DOCUMENT_BYTES,
+    };
+}