r2-relay-channel 0.3.5

package/dist/lifecycle.js

@@ -0,0 +1,296 @@
+import { createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
+import { hasSeenMessage, rememberMessage, saveCheckpointState } from "./checkpoint-store.js";
+import { Service } from "./service.js";
+const activeServices = new Map();
+const runtimeSnapshots = new Map();
+export function createDefaultRuntimeState(accountId) {
+    return createDefaultChannelRuntimeState(accountId, {
+        serverId: null,
+        endpoint: null,
+        bucket: null,
+        lastPollAt: null,
+        checkpointHeadKey: null,
+        lastInboundAt: null,
+        lastOutboundAt: null,
+    });
+}
+export function getRuntimeSnapshot(accountId) {
+    return runtimeSnapshots.get(accountId);
+}
+export function setRuntimeSnapshot(accountId, snapshot) {
+    runtimeSnapshots.set(accountId, snapshot);
+}
+export function touchRuntime(accountId, patch) {
+    const current = runtimeSnapshots.get(accountId) ?? createDefaultRuntimeState(accountId);
+    runtimeSnapshots.set(accountId, {
+        ...current,
+        ...patch,
+    });
+}
+export function getOrCreateService(account) {
+    const existing = activeServices.get(account.accountId);
+    if (existing) {
+        return existing;
+    }
+    const created = new Service({
+        endpoint: account.endpoint,
+        bucket: account.bucket,
+        region: account.region,
+        accessKeyId: account.accessKeyId,
+        secretAccessKey: account.secretAccessKey,
+        forcePathStyle: account.forcePathStyle,
+        peerId: account.serverId,
+    });
+    activeServices.set(account.accountId, created);
+    return created;
+}
+export function clearService(accountId) {
+    activeServices.delete(accountId);
+}
+export function redactEndpoint(endpoint) {
+    try {
+        const url = new URL(endpoint);
+        return `${url.protocol}//${url.host}`;
+    }
+    catch {
+        return endpoint;
+    }
+}
+export function emitRelayDebug(log, message, meta) {
+    if (log?.debug) {
+        log.debug(message, meta);
+        return;
+    }
+    if (log?.info) {
+        log.info(message, meta);
+        return;
+    }
+    if (meta) {
+        console.log(message, JSON.stringify(meta));
+        return;
+    }
+    console.log(message);
+}
+function summarizeRelayMessageForLog(msg) {
+    return {
+        msgId: msg.msg_id ?? null,
+        contentType: msg.content?.type ?? "text",
+        from: msg.from ?? null,
+        to: msg.to ?? null,
+        agentId: msg.route?.agent_id ?? null,
+        conversationId: msg.route?.conversation_id ?? null,
+        statusState: msg.status?.state ?? null,
+    };
+}
+export async function pollRelayInbox(params) {
+    const { cfg, account, service, abortSignal, log, setStatus, syncPublishedIdentity, dispatchInboundMessage, formatInboundRelayBody, classifyInboundRelayMessageFailure, } = params;
+    let interval = account.pollIntervalMs;
+    let state = params.state;
+    while (!abortSignal?.aborted) {
+        try {
+            const pollStartedAt = Date.now();
+            const wakeGapThresholdMs = Math.max(120_000, interval * 5);
+            if (state.lastPollAt && pollStartedAt - state.lastPollAt >= wakeGapThresholdMs) {
+                log?.info?.(`[${account.accountId}] detected long poll gap; refreshing published identity`, {
+                    lastPollAt: state.lastPollAt,
+                    pollStartedAt,
+                    gapMs: pollStartedAt - state.lastPollAt,
+                    wakeGapThresholdMs,
+                });
+                await syncPublishedIdentity(service, account, true);
+            }
+            const batch = await service.collectInboxMessages(account.serverId, state.lastHeadKey);
+            const now = Date.now();
+            state = { ...state, lastPollAt: now };
+            touchRuntime(account.accountId, {
+                lastPollAt: now,
+                checkpointHeadKey: state.lastHeadKey,
+            });
+            setStatus({
+                accountId: account.accountId,
+                lastPollAt: now,
+                checkpointHeadKey: state.lastHeadKey,
+            });
+            if (batch.messages.length > 0) {
+                let batchFailed = false;
+                for (const item of batch.messages) {
+                    if (abortSignal?.aborted) {
+                        break;
+                    }
+                    const msg = item.message;
+                    try {
+                        emitRelayDebug(log, `[${account.accountId}] evaluating inbound relay message`, {
+                            objectKey: item.key,
+                            ...summarizeRelayMessageForLog(msg),
+                        });
+                        if (msg.from === account.serverId) {
+                            emitRelayDebug(log, `[${account.accountId}] skipping self-authored relay message`, {
+                                objectKey: item.key,
+                                ...summarizeRelayMessageForLog(msg),
+                            });
+                            await service.markMessageProcessed(item.key, {
+                                state: "done",
+                                processedBy: account.serverId,
+                            });
+                            state = rememberMessage(state, {
+                                msgId: msg.msg_id,
+                                objectKey: item.key,
+                                at: msg.ts_sent,
+                            });
+                            state = { ...state, lastHeadKey: item.key };
+                            continue;
+                        }
+                        if (msg.to !== account.serverId) {
+                            emitRelayDebug(log, `[${account.accountId}] skipping relay message addressed to different peer`, {
+                                objectKey: item.key,
+                                expectedTo: account.serverId,
+                                ...summarizeRelayMessageForLog(msg),
+                            });
+                            state = { ...state, lastHeadKey: item.key };
+                            continue;
+                        }
+                        if (hasSeenMessage(state, { msgId: msg.msg_id, objectKey: item.key })) {
+                            emitRelayDebug(log, `[${account.accountId}] skipping already-seen relay message`, {
+                                objectKey: item.key,
+                                ...summarizeRelayMessageForLog(msg),
+                            });
+                            state = { ...state, lastHeadKey: batch.checkpointHeadKey };
+                            continue;
+                        }
+                        let processedState = "done";
+                        try {
+                            await dispatchInboundMessage({
+                                cfg,
+                                account,
+                                service,
+                                log,
+                                text: formatInboundRelayBody(msg),
+                                senderId: msg.from,
+                                timestamp: msg.ts_sent || Date.now(),
+                                messageId: msg.msg_id,
+                                route: msg.route,
+                                attachments: (msg.content?.type === "text" ? msg.content.attachments : null) ?? [],
+                            });
+                            emitRelayDebug(log, `[${account.accountId}] dispatched inbound relay message to gateway`, {
+                                objectKey: item.key,
+                                ...summarizeRelayMessageForLog(msg),
+                            });
+                        }
+                        catch (messageErr) {
+                            const message = messageErr instanceof Error ? messageErr.message : String(messageErr);
+                            processedState = classifyInboundRelayMessageFailure(messageErr);
+                            touchRuntime(account.accountId, { lastError: message });
+                            setStatus({ accountId: account.accountId, lastError: message });
+                            log?.error?.(`[${account.accountId}] relay inbound handling failed for ${item.key}: ${message}`, {
+                                ...summarizeRelayMessageForLog(msg),
+                                objectKey: item.key,
+                                processedState,
+                            });
+                        }
+                        try {
+                            await service.markMessageProcessed(item.key, {
+                                state: processedState,
+                                processedBy: account.serverId,
+                            });
+                        }
+                        catch (markErr) {
+                            log?.warn?.(`[${account.accountId}] failed to persist processed state for ${item.key}: ${markErr instanceof Error ? markErr.message : String(markErr)}`);
+                        }
+                        state = rememberMessage(state, {
+                            msgId: msg.msg_id,
+                            objectKey: item.key,
+                            at: msg.ts_sent,
+                        });
+                        state = { ...state, lastHeadKey: item.key };
+                        touchRuntime(account.accountId, {
+                            lastInboundAt: msg.ts_sent || Date.now(),
+                            checkpointHeadKey: state.lastHeadKey,
+                            lastError: processedState === "done" ? null : getRuntimeSnapshot(account.accountId)?.lastError ?? null,
+                        });
+                        setStatus({
+                            accountId: account.accountId,
+                            lastInboundAt: msg.ts_sent || Date.now(),
+                            checkpointHeadKey: state.lastHeadKey,
+                            lastError: processedState === "done" ? null : getRuntimeSnapshot(account.accountId)?.lastError ?? null,
+                        });
+                    }
+                    catch (messageErr) {
+                        const message = messageErr instanceof Error ? messageErr.message : String(messageErr);
+                        touchRuntime(account.accountId, { lastError: message });
+                        setStatus({ accountId: account.accountId, lastError: message });
+                        log?.error?.(`[${account.accountId}] relay inbound handling failed for ${item.key}: ${message}`);
+                        batchFailed = true;
+                        break;
+                    }
+                }
+                if (!batchFailed) {
+                    state = {
+                        ...state,
+                        lastHeadKey: batch.checkpointHeadKey ?? state.lastHeadKey,
+                    };
+                }
+                await saveCheckpointState(state, account.accountId);
+                touchRuntime(account.accountId, {
+                    checkpointHeadKey: state.lastHeadKey,
+                    lastPollAt: state.lastPollAt,
+                    lastInboundAt: state.lastInboundAt,
+                });
+                setStatus({
+                    accountId: account.accountId,
+                    checkpointHeadKey: state.lastHeadKey,
+                    lastPollAt: state.lastPollAt,
+                    lastInboundAt: state.lastInboundAt,
+                });
+                if (!batchFailed) {
+                    interval = account.pollIntervalMs;
+                }
+            }
+            await syncPublishedIdentity(service, account);
+            await sleep(interval, abortSignal);
+            if (!batch.head?.head_key) {
+                interval = Math.min(interval * 2, account.backoffMaxMs);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            touchRuntime(account.accountId, { lastError: message });
+            setStatus({ accountId: account.accountId, lastError: message });
+            log?.error?.(`[${account.accountId}] relay poll failed: ${message}`);
+            await saveCheckpointState(state, account.accountId);
+            await sleep(interval, abortSignal);
+            interval = Math.min(interval * 2, account.backoffMaxMs);
+        }
+    }
+    await saveCheckpointState(state, account.accountId);
+}
+export async function runSweeperLoop(params) {
+    await sleep(60_000, params.abortSignal);
+    while (!params.abortSignal?.aborted) {
+        try {
+            const summaries = await params.service.sweepRetention(params.account.ttl, params.abortSignal);
+            const summaryText = summaries.map((item) => `${item.prefix} scanned=${item.scanned} deleted=${item.deleted}`).join("; ");
+            params.log?.info?.(`[${params.account.accountId}] relay sweeper complete${summaryText ? `: ${summaryText}` : ""}`);
+        }
+        catch (err) {
+            params.log?.warn?.(`[${params.account.accountId}] relay sweeper failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        await sleep(24 * 60 * 60 * 1000, params.abortSignal);
+    }
+}
+function sleep(ms, abortSignal) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            abortSignal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            abortSignal?.removeEventListener("abort", onAbort);
+            resolve();
+        };
+        abortSignal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/media.d.ts

@@ -0,0 +1,30 @@
+import { type OutboundMediaAccess } from "openclaw/plugin-sdk/media-runtime";
+import type { ResolvedR2RelayAccount } from "./config.js";
+import type { AttachmentRef } from "./protocol.js";
+import type { Service } from "./service.js";
+import { type RelayPollLog } from "./lifecycle.js";
+export declare function resolveRelayPayloadMediaUrls(payload: {
+    mediaUrl?: string | null;
+    mediaUrls?: string[] | null;
+}): string[];
+export declare function buildRelayAttachments(params: {
+    account: ResolvedR2RelayAccount;
+    service: Service;
+    targetPeer: string;
+    mediaUrls: string[];
+    workspaceDir?: string | null;
+    mediaAccess?: OutboundMediaAccess;
+    mediaLocalRoots?: readonly string[];
+    mediaReadFile?: (filePath: string) => Promise<Buffer>;
+    log?: RelayPollLog;
+    source?: string;
+}): Promise<{
+    attachments: AttachmentRef[];
+    failures: string[];
+}>;
+export declare function resolveExistingLocalMediaReference(value: string, workspaceDir: string): string | URL;
+export declare function describeLocalMediaReference(value: string): string;
+export declare function normalizeAttachmentContentType(primary?: string | null, fallback?: string | null, fileName?: string | null): string;
+export declare function resolveInboundAttachmentBestEffortMaxBytes(attachment: AttachmentRef, defaultMaxBytes: number): number;
+export declare function resolveInboundAttachmentMaxBytes(attachment: AttachmentRef): number;
+export declare function formatAttachmentContext(attachments?: AttachmentRef[]): string | null;

package/dist/media.js

@@ -0,0 +1,361 @@
+import fs from "node:fs";
+import { kindFromMime, maxBytesForKind, } from "openclaw/plugin-sdk/media-runtime";
+import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
+import { emitRelayDebug } from "./lifecycle.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");
+export function resolveRelayPayloadMediaUrls(payload) {
+    const urls = [
+        ...(payload.mediaUrls ?? []),
+        ...(payload.mediaUrl ? [payload.mediaUrl] : []),
+    ];
+    const seen = new Set();
+    return urls
+        .map((url) => url?.trim())
+        .filter((url) => Boolean(url))
+        .filter((url) => {
+        if (seen.has(url)) {
+            return false;
+        }
+        seen.add(url);
+        return true;
+    });
+}
+export async function buildRelayAttachments(params) {
+    const attachments = [];
+    const failures = [];
+    if (params.mediaUrls.length === 0) {
+        return { attachments, failures };
+    }
+    const relay = params.service.relay;
+    const messageId = relay.shortUuid();
+    const nowMs = Date.now();
+    const maxBytes = Math.max(MAX_IMAGE_BYTES, MAX_VIDEO_BYTES, MAX_AUDIO_BYTES, MAX_DOCUMENT_BYTES);
+    for (let i = 0; i < params.mediaUrls.length; i++) {
+        const rawUrl = params.mediaUrls[i];
+        const attKey = relay.makeAttKey(params.targetPeer, messageId, i + 1, undefined, nowMs);
+        try {
+            const resolvedUrl = isLocalMediaPath(rawUrl)
+                ? resolveExistingLocalMediaReference(rawUrl, params.workspaceDir?.trim() || process.cwd())
+                : rawUrl.trim();
+            if (isLocalMediaPath(rawUrl)) {
+                emitRelayDebug(params.log, `[${params.account.accountId}] resolving local outbound relay media`, {
+                    source: params.source ?? "unknown",
+                    rawUrl,
+                    resolvedPath: resolvedUrl instanceof URL ? resolvedUrl.toString() : resolvedUrl,
+                    workspaceDir: params.workspaceDir?.trim() || process.cwd(),
+                    cwd: process.cwd(),
+                });
+            }
+            else {
+                emitRelayDebug(params.log, `[${params.account.accountId}] fetching remote outbound relay media`, {
+                    source: params.source ?? "unknown",
+                    mediaUrl: rawUrl,
+                });
+            }
+            const media = await loadOutboundMediaFromUrl(resolvedUrl instanceof URL ? resolvedUrl.toString() : resolvedUrl, {
+                maxBytes,
+                mediaAccess: params.mediaAccess,
+                mediaLocalRoots: params.mediaLocalRoots,
+                mediaReadFile: params.mediaReadFile,
+            });
+            const buffer = media.buffer;
+            const fileName = media.fileName ?? null;
+            const contentType = normalizeAttachmentContentType(media.contentType, inferContentTypeFromFileName(fileName), fileName);
+            const dimensions = inferImageDimensions(buffer, contentType);
+            emitRelayDebug(params.log, `[${params.account.accountId}] uploading outbound relay attachment`, {
+                source: params.source ?? "unknown",
+                attKey,
+                fileName,
+                contentType,
+                size: buffer.length,
+                width: dimensions?.width ?? null,
+                height: dimensions?.height ?? null,
+            });
+            await params.service.client.putObject(attKey, buffer, contentType, undefined, undefined, "*");
+            attachments.push({
+                id: `att-${messageId}-${i + 1}`,
+                key: attKey,
+                file_name: fileName,
+                content_type: contentType,
+                size: buffer.length,
+                sha256: null,
+                kind: inferKindFromMediaType(contentType),
+                width: dimensions?.width ?? null,
+                height: dimensions?.height ?? null,
+                duration_ms: null,
+                preview_image_key: null,
+                preview_image_type: null,
+                preview_size: null,
+            });
+            emitRelayDebug(params.log, `[${params.account.accountId}] outbound relay attachment uploaded`, {
+                source: params.source ?? "unknown",
+                attKey,
+                fileName,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failures.push(`${rawUrl}: ${message}`);
+            params.log?.error?.(`[${params.account.accountId}] failed preparing outbound relay attachment`, {
+                source: params.source ?? "unknown",
+                mediaUrl: rawUrl,
+                error: message,
+            });
+        }
+    }
+    return { attachments, failures };
+}
+export function resolveExistingLocalMediaReference(value, workspaceDir) {
+    const trimmed = value.trim();
+    if (trimmed.toLowerCase().startsWith("file://")) {
+        const url = new URL(trimmed);
+        return new URL(`file://${resolveExistingFilePrefix(url.pathname)}`);
+    }
+    const absolute = isAbsolutePath(trimmed)
+        ? trimmed
+        : resolvePath(workspaceDir, trimmed);
+    return resolveExistingFilePrefix(absolute);
+}
+function resolveExistingFilePrefix(value) {
+    const original = value.trim();
+    let candidate = original;
+    while (candidate.length > 1) {
+        try {
+            const stat = fs.statSync(candidate);
+            if (stat.isFile()) {
+                return candidate;
+            }
+        }
+        catch {
+            // keep trimming at whitespace boundaries only
+        }
+        const next = candidate.replace(/\s+\S+\s*$/, "").trimEnd();
+        if (!next || next === candidate) {
+            break;
+        }
+        candidate = next;
+    }
+    return original;
+}
+export function describeLocalMediaReference(value) {
+    const trimmed = value.trim();
+    return pathBasename(trimmed) || trimmed;
+}
+function inferImageDimensions(buffer, contentType) {
+    const lower = contentType?.toLowerCase() ?? "";
+    try {
+        if (lower === "image/png" && buffer.length >= 24 && buffer.readUInt32BE(0) === 0x89504e47) {
+            return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
+        }
+        if ((lower === "image/jpeg" || lower === "image/jpg") && buffer.length >= 4 && buffer[0] === 0xff && buffer[1] === 0xd8) {
+            let offset = 2;
+            while (offset + 9 < buffer.length) {
+                if (buffer[offset] !== 0xff) {
+                    offset += 1;
+                    continue;
+                }
+                const marker = buffer[offset + 1];
+                const length = buffer.readUInt16BE(offset + 2);
+                if (length < 2) {
+                    break;
+                }
+                const isStartOfFrame = (marker >= 0xc0 && marker <= 0xc3) || (marker >= 0xc5 && marker <= 0xc7) || (marker >= 0xc9 && marker <= 0xcb) || (marker >= 0xcd && marker <= 0xcf);
+                if (isStartOfFrame && offset + 8 < buffer.length) {
+                    return { width: buffer.readUInt16BE(offset + 7), height: buffer.readUInt16BE(offset + 5) };
+                }
+                offset += 2 + length;
+            }
+            return null;
+        }
+        if (lower === "image/gif" && buffer.length >= 10 && buffer.toString("ascii", 0, 3) === "GIF") {
+            return { width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8) };
+        }
+        if (lower === "image/webp" && buffer.length >= 30 && buffer.toString("ascii", 0, 4) === "RIFF" && buffer.toString("ascii", 8, 12) === "WEBP") {
+            const chunk = buffer.toString("ascii", 12, 16);
+            if (chunk === "VP8X" && buffer.length >= 30) {
+                return {
+                    width: 1 + buffer.readUIntLE(24, 3),
+                    height: 1 + buffer.readUIntLE(27, 3),
+                };
+            }
+            if (chunk === "VP8 " && buffer.length >= 30) {
+                return {
+                    width: buffer.readUInt16LE(26) & 0x3fff,
+                    height: buffer.readUInt16LE(28) & 0x3fff,
+                };
+            }
+            if (chunk === "VP8L" && buffer.length >= 25) {
+                const bits = buffer.readUInt32LE(21);
+                return {
+                    width: (bits & 0x3fff) + 1,
+                    height: ((bits >> 14) & 0x3fff) + 1,
+                };
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function inferKindFromMediaType(type) {
+    const kind = kindFromMime(type);
+    switch (kind) {
+        case "image":
+            return "image";
+        case "video":
+            return "video";
+        case "audio":
+            return "audio";
+        default:
+            return "file";
+    }
+}
+function isLocalMediaPath(value) {
+    const lower = value.toLowerCase();
+    if (lower.startsWith("http://") || lower.startsWith("https://") || lower.startsWith("data:")) {
+        return false;
+    }
+    if (lower.startsWith("media:")) {
+        return false;
+    }
+    if (lower.startsWith("file://")) {
+        return true;
+    }
+    return isAbsolutePath(value) || value.startsWith("./") || value.startsWith("../");
+}
+function inferContentTypeFromFileName(fileName) {
+    const ext = pathExtname(fileName ?? "").toLowerCase();
+    switch (ext) {
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".png":
+            return "image/png";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        case ".heic":
+            return "image/heic";
+        case ".heif":
+            return "image/heif";
+        case ".mp4":
+            return "video/mp4";
+        case ".mov":
+            return "video/quicktime";
+        case ".webm":
+            return "video/webm";
+        case ".mp3":
+            return "audio/mpeg";
+        case ".m4a":
+            return "audio/mp4";
+        case ".wav":
+            return "audio/wav";
+        case ".ogg":
+            return "audio/ogg";
+        case ".pdf":
+            return "application/pdf";
+        case ".txt":
+            return "text/plain";
+        case ".json":
+            return "application/json";
+        case ".zip":
+            return "application/zip";
+        default:
+            return "application/octet-stream";
+    }
+}
+export function normalizeAttachmentContentType(primary, fallback, fileName) {
+    const primaryTrimmed = primary?.trim();
+    if (primaryTrimmed)
+        return primaryTrimmed;
+    const fallbackTrimmed = fallback?.trim();
+    if (fallbackTrimmed)
+        return fallbackTrimmed;
+    return inferContentTypeFromFileName(fileName);
+}
+export function resolveInboundAttachmentBestEffortMaxBytes(attachment, defaultMaxBytes) {
+    if (typeof attachment.size === "number" && Number.isFinite(attachment.size) && attachment.size > 0) {
+        return Math.max(defaultMaxBytes, Math.min(attachment.size + 1024 * 1024, 64 * 1024 * 1024));
+    }
+    return Math.max(defaultMaxBytes, 64 * 1024 * 1024);
+}
+function isImageAttachment(attachment) {
+    if (attachment.kind === "image") {
+        return true;
+    }
+    return Boolean(attachment.content_type?.toLowerCase().startsWith("image/"));
+}
+function isVideoAttachment(attachment) {
+    if (attachment.kind === "video") {
+        return true;
+    }
+    return Boolean(attachment.content_type?.toLowerCase().startsWith("video/"));
+}
+function isAudioAttachment(attachment) {
+    if (attachment.kind === "audio") {
+        return true;
+    }
+    return Boolean(attachment.content_type?.toLowerCase().startsWith("audio/"));
+}
+export function resolveInboundAttachmentMaxBytes(attachment) {
+    if (isImageAttachment(attachment))
+        return MAX_IMAGE_BYTES;
+    if (isVideoAttachment(attachment))
+        return MAX_VIDEO_BYTES;
+    if (isAudioAttachment(attachment))
+        return MAX_AUDIO_BYTES;
+    return MAX_DOCUMENT_BYTES;
+}
+export function formatAttachmentContext(attachments) {
+    if (!attachments || attachments.length === 0)
+        return null;
+    const lines = attachments.map((att, i) => {
+        const parts = [`[Attachment ${i + 1}]`];
+        if (att.file_name)
+            parts.push(`name: ${att.file_name}`);
+        if (att.content_type)
+            parts.push(`type: ${att.content_type}`);
+        if (att.kind && att.kind !== "unknown")
+            parts.push(`kind: ${att.kind}`);
+        if (att.size)
+            parts.push(`size: ${att.size} bytes`);
+        if (att.width && att.height)
+            parts.push(`dimensions: ${att.width}x${att.height}`);
+        if (att.duration_ms)
+            parts.push(`duration: ${(att.duration_ms / 1000).toFixed(1)}s`);
+        return parts.join(", ");
+    });
+    return lines.join("\n");
+}
+function pathBasename(value) {
+    return value.split(/[\\/]/).pop() ?? value;
+}
+function pathExtname(value) {
+    const base = pathBasename(value);
+    const index = base.lastIndexOf(".");
+    return index >= 0 ? base.slice(index) : "";
+}
+function isAbsolutePath(value) {
+    return value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value);
+}
+function resolvePath(base, relative) {
+    const normalizedBase = base.replace(/[\\/]+$/, "");
+    const parts = `${normalizedBase}/${relative}`.split(/[\\/]+/);
+    const resolved = [];
+    for (const part of parts) {
+        if (!part || part === ".") {
+            continue;
+        }
+        if (part === "..") {
+            resolved.pop();
+            continue;
+        }
+        resolved.push(part);
+    }
+    return `${normalizedBase.startsWith("/") ? "/" : ""}${resolved.join("/")}`;
+}