@hywkp/sider 0.0.4 → 0.0.5

package/dist/src/channel.js

@@ -1,34 +1,11 @@
 import { DEFAULT_ACCOUNT_ID, createReplyPrefixOptions, createTypingCallbacks, formatTextWithAttachmentLinks, normalizeAccountId, resolveOutboundMediaUrls, } from "openclaw/plugin-sdk";
+import { resolveInboundSiderMedia } from "./inbound-media.js";
+import { buildSiderPartsFromReplyPayload } from "./media-upload.js";
 const CHANNEL_ID = "sider";
 const DEFAULT_GATEWAY_URL = "http://47.82.167.142:3001";
 const DEFAULT_CONNECT_TIMEOUT_MS = 8_000;
 const DEFAULT_SEND_TIMEOUT_MS = 12_000;
 const DEFAULT_RECONNECT_DELAY_MS = 2_000;
-const IMAGE_EXTENSIONS = new Set([
-    ".jpg",
-    ".jpeg",
-    ".png",
-    ".gif",
-    ".webp",
-    ".bmp",
-    ".svg",
-    ".heic",
-    ".heif",
-    ".avif",
-]);
-const MIME_BY_EXTENSION = {
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".png": "image/png",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-    ".bmp": "image/bmp",
-    ".svg": "image/svg+xml",
-    ".pdf": "application/pdf",
-    ".txt": "text/plain",
-    ".json": "application/json",
-    ".zip": "application/zip",
-};
 const meta = {
     id: CHANNEL_ID,
     label: "Sider",
@@ -40,6 +17,9 @@ const meta = {
     order: 97,
 };
 let runtimeRef = null;
+const SIDER_SESSION_BINDING_TTL_MS = 6 * 60 * 60 * 1000;
+const SIDER_SESSION_BINDING_MAX = 512;
+const siderSessionBindings = new Map();
 export function setSiderRuntime(runtime) {
     runtimeRef = runtime;
 }
@@ -65,6 +45,96 @@ function logWarn(message, data) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function normalizeSessionBindingKey(raw) {
+    const key = raw?.trim().toLowerCase();
+    return key || undefined;
+}
+function pruneSiderSessionBindings(now = Date.now()) {
+    for (const [key, binding] of siderSessionBindings) {
+        if (now - binding.lastSeenAt > SIDER_SESSION_BINDING_TTL_MS) {
+            siderSessionBindings.delete(key);
+        }
+    }
+    if (siderSessionBindings.size <= SIDER_SESSION_BINDING_MAX) {
+        return;
+    }
+    const sorted = [...siderSessionBindings.entries()].sort((a, b) => a[1].lastSeenAt - b[1].lastSeenAt);
+    const overflow = siderSessionBindings.size - SIDER_SESSION_BINDING_MAX;
+    for (let index = 0; index < overflow; index += 1) {
+        const key = sorted[index]?.[0];
+        if (key) {
+            siderSessionBindings.delete(key);
+        }
+    }
+}
+function rememberSiderSessionBinding(params) {
+    const key = normalizeSessionBindingKey(params.sessionKey);
+    if (!key) {
+        return;
+    }
+    const now = Date.now();
+    const existing = siderSessionBindings.get(key);
+    if (existing) {
+        existing.account = params.account;
+        existing.sessionId = params.sessionId;
+        existing.lastSeenAt = now;
+        pruneSiderSessionBindings(now);
+        return;
+    }
+    siderSessionBindings.set(key, {
+        account: params.account,
+        sessionId: params.sessionId,
+        lastSeenAt: now,
+        toolSeq: 0,
+        currentToolCallId: undefined,
+        callIdByToolCallId: new Map(),
+    });
+    pruneSiderSessionBindings(now);
+}
+function resolveSiderSessionBinding(sessionKey) {
+    const key = normalizeSessionBindingKey(sessionKey);
+    if (!key) {
+        return undefined;
+    }
+    const binding = siderSessionBindings.get(key);
+    if (!binding) {
+        return undefined;
+    }
+    binding.lastSeenAt = Date.now();
+    return binding;
+}
+function toJsonSafeValue(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return String(value);
+    }
+}
+function extractToolResultText(result) {
+    const maxChars = 4000;
+    const clip = (text) => {
+        if (text.length <= maxChars) {
+            return text;
+        }
+        return `${text.slice(0, maxChars)}...`;
+    };
+    const record = toRecord(result);
+    if (!record) {
+        return "";
+    }
+    const candidateKeys = ["text", "content", "message", "output", "stdout"];
+    for (const key of candidateKeys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim()) {
+            return clip(value.trim());
+        }
+    }
+    return "";
+}
 function toRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return null;
@@ -138,6 +208,26 @@ function parseSessionTarget(raw) {
     }
     return trimmed;
 }
+function normalizeSiderMessagingTarget(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const withoutProviderPrefix = trimmed.replace(/^sider:/i, "").trim();
+    return withoutProviderPrefix || undefined;
+}
+function looksLikeSiderTargetId(raw, normalized) {
+    const candidate = (normalized ?? raw ?? "").trim();
+    if (!candidate) {
+        return false;
+    }
+    const match = candidate.match(/^session:(.+)$/i);
+    if (match) {
+        return match[1].trim().length > 0;
+    }
+    // Sider has no directory lookup yet; treat non-whitespace tokens as explicit ids.
+    return !/\s/.test(candidate);
+}
 function resolveOutboundSessionId(params) {
     const target = params.to?.trim() || params.account.defaultTo?.trim() || "";
     if (!target) {
@@ -415,94 +505,6 @@ async function sendSiderEventBestEffort(params) {
         });
     }
 }
-function extFromMediaUrl(raw) {
-    try {
-        if (/^https?:\/\//i.test(raw)) {
-            const pathname = new URL(raw).pathname;
-            return pathname.includes(".") ? pathname.slice(pathname.lastIndexOf(".")).toLowerCase() : "";
-        }
-    }
-    catch {
-        // no-op
-    }
-    const qPos = raw.indexOf("?");
-    const sanitized = qPos >= 0 ? raw.slice(0, qPos) : raw;
-    const slashPos = sanitized.lastIndexOf("/");
-    const last = slashPos >= 0 ? sanitized.slice(slashPos + 1) : sanitized;
-    const dotPos = last.lastIndexOf(".");
-    return dotPos >= 0 ? last.slice(dotPos).toLowerCase() : "";
-}
-function fileNameFromMediaUrl(raw) {
-    try {
-        if (/^https?:\/\//i.test(raw)) {
-            const pathname = new URL(raw).pathname;
-            const seg = pathname.split("/").filter(Boolean).pop();
-            return seg || undefined;
-        }
-    }
-    catch {
-        // no-op
-    }
-    const qPos = raw.indexOf("?");
-    const sanitized = qPos >= 0 ? raw.slice(0, qPos) : raw;
-    const seg = sanitized.split("/").filter(Boolean).pop();
-    return seg || undefined;
-}
-function inferMediaKind(mediaUrl) {
-    const ext = extFromMediaUrl(mediaUrl);
-    return IMAGE_EXTENSIONS.has(ext) ? "image" : "file";
-}
-function inferMediaMimeType(mediaUrl) {
-    const ext = extFromMediaUrl(mediaUrl);
-    return MIME_BY_EXTENSION[ext];
-}
-async function uploadMediaToSider(params) {
-    const mediaKind = inferMediaKind(params.mediaUrl);
-    const fileName = fileNameFromMediaUrl(params.mediaUrl);
-    const mimeType = inferMediaMimeType(params.mediaUrl);
-    // TODO(siderclaw-upload): Upload local/remote media to sider server and return hosted resource URL.
-    // Current placeholder returns the original mediaUrl directly.
-    const resourceUrl = params.mediaUrl;
-    void params.account;
-    return {
-        resourceUrl,
-        mediaKind,
-        mimeType,
-        fileName,
-    };
-}
-async function buildSiderPartsFromReplyPayload(params) {
-    const parts = [];
-    const text = params.payload.text?.trim();
-    if (text) {
-        parts.push({
-            type: "core.text",
-            spec_version: 1,
-            payload: { text },
-        });
-    }
-    const mediaUrls = resolveOutboundMediaUrls(params.payload);
-    for (const mediaUrl of mediaUrls) {
-        const uploaded = await uploadMediaToSider({
-            account: params.account,
-            mediaUrl,
-        });
-        parts.push({
-            type: "core.media",
-            spec_version: 1,
-            payload: {
-                media_type: uploaded.mediaKind,
-                url: uploaded.resourceUrl,
-                mime_type: uploaded.mimeType,
-                file_name: uploaded.fileName,
-            },
-            meta: {
-                source_media_url: mediaUrl,
-            },
-        });
-    }
-    return parts;
-}
 function parseTextFromPart(part) {
     if (part.type !== "core.text") {
         return null;
@@ -519,21 +521,27 @@ function parseTextFromPart(part) {
     return null;
 }
 function parseMediaFromPart(part) {
-    if (part.type !== "core.media") {
+    if (part.type !== "core.media" && part.type !== "core.file") {
         return null;
     }
     const payload = toRecord(part.payload);
     if (!payload) {
         return null;
     }
-    const urlCandidates = [payload.url, payload.resource_url, payload.media_url];
+    const urlCandidates = [payload.download_url, payload.url, payload.resource_url, payload.media_url];
     const url = urlCandidates.find((entry) => typeof entry === "string" && entry.trim());
     if (!url) {
         return null;
     }
-    const mimeCandidates = [payload.mime_type, payload.content_type];
+    const mimeCandidates = [payload.mime, payload.mime_type, payload.content_type];
     const mimeType = mimeCandidates.find((entry) => typeof entry === "string" && entry.trim());
-    return { url: url.trim(), mimeType: mimeType?.trim() || undefined };
+    const fileNameCandidates = [payload.name, payload.file_name];
+    const fileName = fileNameCandidates.find((entry) => typeof entry === "string" && entry.trim());
+    return {
+        url: url.trim(),
+        mimeType: mimeType?.trim() || undefined,
+        fileName: fileName?.trim() || undefined,
+    };
 }
 function buildEventMeta(params) {
     return {
@@ -594,6 +602,147 @@ function buildStreamingDoneEvent(params) {
         meta: buildEventMeta({ accountId: params.accountId }),
     };
 }
+function buildToolCallEvent(params) {
+    return {
+        eventType: "tool.call",
+        payload: {
+            session_id: params.sessionId,
+            seq: params.seq,
+            call_id: params.callId,
+            phase: params.phase,
+            tool_name: params.toolName,
+            tool_call_id: params.toolCallId,
+            run_id: params.runId,
+            session_key: params.sessionKey,
+            tool_args: params.toolArgs,
+            error: params.error,
+            duration_ms: params.durationMs,
+            ts: Date.now(),
+        },
+        meta: buildEventMeta({ accountId: params.accountId }),
+    };
+}
+function buildToolResultEvent(params) {
+    const text = extractToolResultText(params.result);
+    const safeResult = toJsonSafeValue(params.result);
+    const safeToolArgs = toJsonSafeValue(params.toolArgs);
+    return {
+        eventType: "tool.result",
+        payload: {
+            session_id: params.sessionId,
+            seq: params.seq,
+            call_id: params.callId,
+            tool_name: params.toolName,
+            tool_call_id: params.toolCallId,
+            run_id: params.runId,
+            session_key: params.sessionKey,
+            tool_args: safeToolArgs,
+            result: safeResult,
+            error: params.error,
+            duration_ms: params.durationMs,
+            text,
+            has_text: text.trim().length > 0,
+            media_urls: [],
+            media_count: 0,
+            is_error: Boolean(params.error),
+            ts: Date.now(),
+        },
+        meta: buildEventMeta({ accountId: params.accountId }),
+    };
+}
+function resolveRelayCallIdForToolEvent(params) {
+    if (params.toolCallId) {
+        const existing = params.binding.callIdByToolCallId.get(params.toolCallId);
+        if (existing) {
+            params.binding.currentToolCallId = existing;
+            return existing;
+        }
+        const created = crypto.randomUUID();
+        params.binding.callIdByToolCallId.set(params.toolCallId, created);
+        params.binding.currentToolCallId = created;
+        return created;
+    }
+    if (params.phase === "start" || !params.binding.currentToolCallId) {
+        params.binding.currentToolCallId = crypto.randomUUID();
+    }
+    return params.binding.currentToolCallId;
+}
+function clearRelayCallIdForToolEvent(params) {
+    if (params.toolCallId) {
+        params.binding.callIdByToolCallId.delete(params.toolCallId);
+    }
+    if (params.binding.currentToolCallId === params.callId) {
+        params.binding.currentToolCallId = undefined;
+    }
+}
+export async function emitSiderToolHookEvent(params) {
+    const binding = resolveSiderSessionBinding(params.sessionKey);
+    if (!binding) {
+        logDebug("skip sider tool hook event: session binding not found", {
+            sessionKey: params.sessionKey,
+            toolName: params.toolName,
+            toolCallId: params.toolCallId,
+            phase: params.phase,
+        });
+        return;
+    }
+    const callId = resolveRelayCallIdForToolEvent({
+        binding,
+        phase: params.phase,
+        toolCallId: params.toolCallId,
+    });
+    if (params.phase === "start") {
+        binding.toolSeq += 1;
+        const toolCallEvent = buildToolCallEvent({
+            sessionId: binding.sessionId,
+            accountId: binding.account.accountId,
+            seq: binding.toolSeq,
+            callId,
+            phase: "start",
+            toolName: params.toolName,
+            toolCallId: params.toolCallId,
+            runId: params.runId,
+            sessionKey: params.sessionKey,
+            toolArgs: params.params,
+            error: params.error,
+            durationMs: params.durationMs,
+        });
+        await sendSiderEventBestEffort({
+            account: binding.account,
+            sessionId: binding.sessionId,
+            event: toolCallEvent,
+            context: "tool.call.hook.start",
+        });
+    }
+    if (params.phase !== "start") {
+        binding.toolSeq += 1;
+        const toolResultEvent = buildToolResultEvent({
+            sessionId: binding.sessionId,
+            accountId: binding.account.accountId,
+            seq: binding.toolSeq,
+            callId,
+            toolName: params.toolName,
+            toolCallId: params.toolCallId,
+            runId: params.runId,
+            sessionKey: params.sessionKey,
+            toolArgs: params.params,
+            result: params.result,
+            error: params.error,
+            durationMs: params.durationMs,
+        });
+        await sendSiderEventBestEffort({
+            account: binding.account,
+            sessionId: binding.sessionId,
+            event: toolResultEvent,
+            context: `tool.result.hook.${params.phase}`,
+        });
+        clearRelayCallIdForToolEvent({
+            binding,
+            callId,
+            toolCallId: params.toolCallId,
+        });
+    }
+}
 async function openStreamingSessionIfNeeded(params) {
     if (params.streamState.active && params.streamState.streamId) {
         return;
@@ -752,34 +901,42 @@ async function handleStreamingPartialSnapshot(params) {
     params.streamState.accumulatedBlockText = params.snapshot;
 }
 async function deliverReplyPayloadToSider(params) {
+    const payloadMediaUrls = resolveOutboundMediaUrls(params.payload);
     if (params.kind === "block") {
         const delta = typeof params.payload.text === "string" ? params.payload.text : "";
-        if (delta.length === 0) {
-            return;
-        }
-        params.streamState.blockDeltaCount += 1;
-        mergeBlockTextIntoStreamState({
-            streamState: params.streamState,
-            text: delta,
-        });
-        if (params.streamState.partialDeltaCount === 0) {
-            await sendStreamingDeltaEvent({
-                account: params.account,
-                sessionId: params.sessionId,
+        if (delta.length > 0) {
+            params.streamState.blockDeltaCount += 1;
+            mergeBlockTextIntoStreamState({
                 streamState: params.streamState,
-                delta,
-                context: "stream.delta.block",
+                text: delta,
             });
+            if (params.streamState.partialDeltaCount === 0) {
+                await sendStreamingDeltaEvent({
+                    account: params.account,
+                    sessionId: params.sessionId,
+                    streamState: params.streamState,
+                    delta,
+                    context: "stream.delta.block",
+                });
+            }
+            else {
+                logDebug("skip block stream delta because partial streaming is active", {
+                    accountId: params.account.accountId,
+                    sessionId: params.sessionId,
+                    deltaLength: delta.length,
+                    partialDeltaCount: params.streamState.partialDeltaCount,
+                });
+            }
         }
-        else {
-            logDebug("skip block stream delta because partial streaming is active", {
-                accountId: params.account.accountId,
-                sessionId: params.sessionId,
-                deltaLength: delta.length,
-                partialDeltaCount: params.streamState.partialDeltaCount,
-            });
+        if (payloadMediaUrls.length === 0) {
+            return;
         }
-        return;
+        logDebug("block payload contains media; sending persisted sider message", {
+            accountId: params.account.accountId,
+            sessionId: params.sessionId,
+            mediaCount: payloadMediaUrls.length,
+            hasText: delta.length > 0,
+        });
     }
     if (params.kind === "final") {
         await flushStreamEventQueue(params.streamState);
@@ -810,20 +967,39 @@ async function deliverReplyPayloadToSider(params) {
     }
     const parts = await buildSiderPartsFromReplyPayload({
         account: params.account,
+        sessionId: params.sessionId,
         payload: params.payload,
+        logger: {
+            debug: logDebug,
+            warn: logWarn,
+        },
     });
     if (parts.length === 0) {
+        logDebug("skip sider outbound message: empty parts", {
+            accountId: params.account.accountId,
+            sessionId: params.sessionId,
+            kind: params.kind,
+            hasText: typeof params.payload.text === "string" && params.payload.text.length > 0,
+            mediaCount: payloadMediaUrls.length,
+        });
         return;
     }
+    logDebug("sending sider outbound message from payload", {
+        accountId: params.account.accountId,
+        sessionId: params.sessionId,
+        kind: params.kind,
+        partTypes: parts.map((part) => part.type),
+        mediaCount: payloadMediaUrls.length,
+    });
     await sendMessageToSider({
         account: params.account,
         sessionId: params.sessionId,
         parts,
     });
-    if (params.kind === "final" &&
-        typeof params.payload.text === "string" &&
-        params.payload.text.trim()) {
+    if (params.kind === "final" || payloadMediaUrls.length > 0) {
         params.streamState.persistedFinalText = true;
+    }
+    if (params.kind === "final") {
         params.streamState.accumulatedBlockText = "";
         params.streamState.blockDeltaCount = 0;
         params.streamState.partialDeltaCount = 0;
@@ -856,7 +1032,7 @@ async function handleInboundRealtimeMessage(params) {
     }
     const rawText = textChunks.join("\n").trim();
     const mediaUrls = mediaItems.map((item) => item.url);
-    const mediaTypes = mediaItems
+    const parsedMediaTypes = mediaItems
         .map((item) => item.mimeType)
         .filter((item) => Boolean(item));
     const hasControlCommand = rawText ? core.channel.text.hasControlCommand(rawText, cfg) : false;
@@ -895,7 +1071,27 @@ async function handleInboundRealtimeMessage(params) {
             commandAuthorized,
         });
     }
-    const bodyForAgent = formatTextWithAttachmentLinks(rawText, mediaUrls);
+    const resolvedInboundMedia = await resolveInboundSiderMedia({
+        runtime: core,
+        cfg,
+        accountId: account.accountId,
+        mediaItems,
+        logger: {
+            debug: logDebug,
+            warn: logWarn,
+        },
+    });
+    const unresolvedMediaUrls = resolvedInboundMedia.unresolvedMedia.map((item) => item.url);
+    if (unresolvedMediaUrls.length > 0) {
+        logWarn("sider inbound media fallback to attachment url", {
+            accountId: account.accountId,
+            sessionId,
+            unresolvedCount: unresolvedMediaUrls.length,
+            unresolvedMediaUrls,
+        });
+    }
+    const bodyForAgent = formatTextWithAttachmentLinks(rawText, unresolvedMediaUrls);
+    const mediaPayload = resolvedInboundMedia.mediaPayload;
     const route = core.channel.routing.resolveAgentRoute({
         cfg,
         channel: CHANNEL_ID,
@@ -937,12 +1133,21 @@ async function handleInboundRealtimeMessage(params) {
         WasMentioned: true,
         OriginatingChannel: CHANNEL_ID,
         OriginatingTo: to,
-        MediaUrl: mediaUrls[0],
-        MediaUrls: mediaUrls.length > 0 ? mediaUrls : undefined,
-        MediaType: mediaTypes[0],
-        MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+        ...mediaPayload,
+        MediaUrl: mediaPayload.MediaUrl ||
+            (unresolvedMediaUrls.length > 0 ? unresolvedMediaUrls[0] : undefined),
+        MediaUrls: mediaPayload.MediaUrls ||
+            (unresolvedMediaUrls.length > 0 ? unresolvedMediaUrls : undefined),
+        MediaType: mediaPayload.MediaType || parsedMediaTypes[0],
+        MediaTypes: mediaPayload.MediaTypes ||
+            (parsedMediaTypes.length > 0 ? parsedMediaTypes : undefined),
         CommandAuthorized: commandAuthorized,
     });
+    rememberSiderSessionBinding({
+        sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+        account,
+        sessionId,
+    });
     const storePath = core.channel.session.resolveStorePath(cfg.session?.store, {
         agentId: route.agentId,
     });
@@ -971,6 +1176,8 @@ async function handleInboundRealtimeMessage(params) {
         commandAuthorized,
         textLength: rawText.length,
         mediaCount: mediaUrls.length,
+        mediaDownloadedCount: mediaPayload.MediaPaths?.length ?? 0,
+        mediaDownloadFailedCount: unresolvedMediaUrls.length,
     });
     const streamState = {
         active: false,
@@ -1128,8 +1335,6 @@ async function handleInboundRealtimeMessage(params) {
         });
         streamState.persistedFinalText = true;
         streamState.accumulatedBlockText = "";
-        streamState.partialDeltaCount = 0;
-        streamState.partialSnapshot = "";
     }
 }
 async function handleInboundRealtimeEvent(params) {
@@ -1360,7 +1565,7 @@ export const siderPlugin = {
                 conversationId: result.conversationId,
             };
         },
-        sendMedia: async ({ cfg, accountId, to, text, mediaUrl }) => {
+        sendMedia: async ({ cfg, accountId, to, text, mediaUrl, mediaLocalRoots }) => {
             const account = resolveSiderAccount(cfg, accountId);
             if (!account.configured) {
                 throw new Error(`sider account "${account.accountId}" is not configured: missing gatewayUrl/sessionId(or sessionKey)/relayId`);
@@ -1368,10 +1573,16 @@ export const siderPlugin = {
             const sessionId = resolveOutboundSessionId({ account, to });
             const parts = await buildSiderPartsFromReplyPayload({
                 account,
+                sessionId,
                 payload: {
                     text,
                     mediaUrl,
                 },
+                mediaLocalRoots,
+                logger: {
+                    debug: logDebug,
+                    warn: logWarn,
+                },
             });
             if (parts.length === 0) {
                 throw new Error("sider sendMedia requires text and/or mediaUrl");
@@ -1404,5 +1615,12 @@ export const siderPlugin = {
             ctx.log?.info(`[${account.accountId}] sider relay monitor stopped`);
         },
     },
+    messaging: {
+        normalizeTarget: normalizeSiderMessagingTarget,
+        targetResolver: {
+            looksLikeId: looksLikeSiderTargetId,
+            hint: "session:<sessionId> (or raw <sessionId>)",
+        },
+    },
 };
 //# sourceMappingURL=channel.js.map