@hywkp/sider 0.0.3 → 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,83 +602,409 @@ function buildStreamingDoneEvent(params) {
         meta: buildEventMeta({ accountId: params.accountId }),
     };
 }
-async function deliverReplyPayloadToSider(params) {
-    if (params.kind === "block") {
-        const delta = typeof params.payload.text === "string" ? params.payload.text : "";
-        if (delta.length === 0) {
-            return;
-        }
-        if (!params.streamState.active || !params.streamState.streamId) {
-            params.streamState.active = true;
-            params.streamState.streamId = crypto.randomUUID();
-            params.streamState.seq = 0;
-            const streamStartEvent = buildStreamingStartEvent({
-                sessionId: params.sessionId,
-                streamId: params.streamState.streamId,
-                accountId: params.account.accountId,
-            });
-            await sendSiderEventBestEffort({
-                account: params.account,
-                sessionId: params.sessionId,
-                event: streamStartEvent,
-                context: "stream.start",
-            });
+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;
         }
-        params.streamState.seq += 1;
-        const streamDeltaEvent = buildStreamingDeltaEvent({
-            sessionId: params.sessionId,
-            streamId: params.streamState.streamId,
-            seq: params.streamState.seq,
-            delta,
-            accountId: params.account.accountId,
+        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,
         });
-        logDebug("sending stream delta event", {
-            accountId: params.account.accountId,
-            sessionId: params.sessionId,
-            eventType: streamDeltaEvent.eventType,
-            streamId: params.streamState.streamId,
-            seq: params.streamState.seq,
-            deltaLength: delta.length,
+        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: params.account,
-            sessionId: params.sessionId,
-            event: streamDeltaEvent,
-            context: "stream.delta",
+            account: binding.account,
+            sessionId: binding.sessionId,
+            event: toolCallEvent,
+            context: "tool.call.hook.start",
         });
-        return;
     }
+    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) {
-        params.streamState.seq += 1;
-        const streamDoneEvent = buildStreamingDoneEvent({
-            sessionId: params.sessionId,
-            streamId: params.streamState.streamId,
-            seq: params.streamState.seq,
+        return;
+    }
+    params.streamState.active = true;
+    params.streamState.streamId = crypto.randomUUID();
+    params.streamState.seq = 0;
+    const streamStartEvent = buildStreamingStartEvent({
+        sessionId: params.sessionId,
+        streamId: params.streamState.streamId,
+        accountId: params.account.accountId,
+    });
+    await sendSiderEventBestEffort({
+        account: params.account,
+        sessionId: params.sessionId,
+        event: streamStartEvent,
+        context: "stream.start",
+    });
+}
+async function sendStreamingDeltaEvent(params) {
+    if (!params.delta) {
+        return;
+    }
+    await openStreamingSessionIfNeeded({
+        account: params.account,
+        sessionId: params.sessionId,
+        streamState: params.streamState,
+    });
+    params.streamState.seq += 1;
+    const streamDeltaEvent = buildStreamingDeltaEvent({
+        sessionId: params.sessionId,
+        streamId: params.streamState.streamId,
+        seq: params.streamState.seq,
+        delta: params.delta,
+        accountId: params.account.accountId,
+    });
+    logDebug("sending stream delta event", {
+        accountId: params.account.accountId,
+        sessionId: params.sessionId,
+        eventType: streamDeltaEvent.eventType,
+        streamId: params.streamState.streamId,
+        seq: params.streamState.seq,
+        deltaLength: params.delta.length,
+        context: params.context,
+    });
+    await sendSiderEventBestEffort({
+        account: params.account,
+        sessionId: params.sessionId,
+        event: streamDeltaEvent,
+        context: params.context,
+    });
+}
+async function closeStreamingSessionIfActive(params) {
+    if (!params.streamState.active || !params.streamState.streamId) {
+        return;
+    }
+    params.streamState.seq += 1;
+    const streamDoneEvent = buildStreamingDoneEvent({
+        sessionId: params.sessionId,
+        streamId: params.streamState.streamId,
+        seq: params.streamState.seq,
+        accountId: params.account.accountId,
+        reason: params.reason,
+    });
+    await sendSiderEventBestEffort({
+        account: params.account,
+        sessionId: params.sessionId,
+        event: streamDoneEvent,
+        context: params.context,
+    });
+    params.streamState.active = false;
+    params.streamState.streamId = undefined;
+    params.streamState.seq = 0;
+}
+function enqueueStreamEventTask(params) {
+    const next = params.streamState.streamEventQueue.then(params.task).catch((err) => {
+        logWarn("sider stream event queue task failed", {
+            error: String(err),
+        });
+    });
+    params.streamState.streamEventQueue = next;
+    return next;
+}
+async function flushStreamEventQueue(streamState) {
+    await streamState.streamEventQueue;
+}
+function derivePartialDelta(params) {
+    const prev = params.previous;
+    const next = params.next;
+    if (!next) {
+        return "";
+    }
+    if (!prev) {
+        return next;
+    }
+    if (next === prev) {
+        return "";
+    }
+    if (next.startsWith(prev)) {
+        return next.slice(prev.length);
+    }
+    if (prev.startsWith(next)) {
+        // Snapshot regressed (restart/truncation); wait for next stable snapshot.
+        return "";
+    }
+    const maxOverlap = Math.min(prev.length, next.length);
+    for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+        if (prev.endsWith(next.slice(0, overlap))) {
+            return next.slice(overlap);
+        }
+    }
+    return next;
+}
+function mergeBlockTextIntoStreamState(params) {
+    const next = params.text;
+    if (!next) {
+        return;
+    }
+    const prev = params.streamState.accumulatedBlockText;
+    if (!prev) {
+        params.streamState.accumulatedBlockText = next;
+        return;
+    }
+    if (next.startsWith(prev)) {
+        // Some runtimes emit cumulative text snapshots.
+        params.streamState.accumulatedBlockText = next;
+        return;
+    }
+    if (prev.endsWith(next)) {
+        // Avoid duplicating identical trailing chunks.
+        return;
+    }
+    params.streamState.accumulatedBlockText += next;
+}
+async function handleStreamingPartialSnapshot(params) {
+    if (!params.snapshot) {
+        return;
+    }
+    const delta = derivePartialDelta({
+        previous: params.streamState.partialSnapshot,
+        next: params.snapshot,
+    });
+    params.streamState.partialSnapshot = params.snapshot;
+    if (!delta) {
+        return;
+    }
+    await sendStreamingDeltaEvent({
+        account: params.account,
+        sessionId: params.sessionId,
+        streamState: params.streamState,
+        delta,
+        context: "stream.delta.partial",
+    });
+    params.streamState.partialDeltaCount += 1;
+    // Partial callbacks carry the latest visible assistant snapshot.
+    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) {
+            params.streamState.blockDeltaCount += 1;
+            mergeBlockTextIntoStreamState({
+                streamState: params.streamState,
+                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,
+                });
+            }
+        }
+        if (payloadMediaUrls.length === 0) {
+            return;
+        }
+        logDebug("block payload contains media; sending persisted sider message", {
             accountId: params.account.accountId,
-            reason: "final",
+            sessionId: params.sessionId,
+            mediaCount: payloadMediaUrls.length,
+            hasText: delta.length > 0,
         });
-        await sendSiderEventBestEffort({
+    }
+    if (params.kind === "final") {
+        await flushStreamEventQueue(params.streamState);
+        if (!params.streamState.active && params.streamState.blockDeltaCount === 0) {
+            const finalText = typeof params.payload.text === "string" ? params.payload.text : "";
+            if (finalText.length > 0) {
+                logDebug("no block delta observed; sending synthetic stream events from final payload", {
+                    accountId: params.account.accountId,
+                    sessionId: params.sessionId,
+                    textLength: finalText.length,
+                });
+                await sendStreamingDeltaEvent({
+                    account: params.account,
+                    sessionId: params.sessionId,
+                    streamState: params.streamState,
+                    delta: finalText,
+                    context: "stream.delta.final-fallback",
+                });
+            }
+        }
+        await closeStreamingSessionIfActive({
             account: params.account,
             sessionId: params.sessionId,
-            event: streamDoneEvent,
+            streamState: params.streamState,
+            reason: "final",
             context: "stream.done",
         });
-        params.streamState.active = false;
-        params.streamState.streamId = undefined;
-        params.streamState.seq = 0;
     }
     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" || payloadMediaUrls.length > 0) {
+        params.streamState.persistedFinalText = true;
+    }
+    if (params.kind === "final") {
+        params.streamState.accumulatedBlockText = "";
+        params.streamState.blockDeltaCount = 0;
+        params.streamState.partialDeltaCount = 0;
+        params.streamState.partialSnapshot = "";
+    }
 }
 async function handleInboundRealtimeMessage(params) {
     const { cfg, account, event } = params;
@@ -698,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;
@@ -737,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,
@@ -779,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,
     });
@@ -813,11 +1176,19 @@ async function handleInboundRealtimeMessage(params) {
         commandAuthorized,
         textLength: rawText.length,
         mediaCount: mediaUrls.length,
+        mediaDownloadedCount: mediaPayload.MediaPaths?.length ?? 0,
+        mediaDownloadFailedCount: unresolvedMediaUrls.length,
     });
     const streamState = {
         active: false,
         streamId: undefined,
         seq: 0,
+        blockDeltaCount: 0,
+        partialDeltaCount: 0,
+        partialSnapshot: "",
+        accumulatedBlockText: "",
+        persistedFinalText: false,
+        streamEventQueue: Promise.resolve(),
     };
     const typingCallbacks = createTypingCallbacks({
         start: async () => {
@@ -871,6 +1242,7 @@ async function handleInboundRealtimeMessage(params) {
             });
         },
     });
+    let dispatchCompleted = false;
     try {
         await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
             ctx: ctxPayload,
@@ -879,6 +1251,13 @@ async function handleInboundRealtimeMessage(params) {
                 ...prefixOptions,
                 typingCallbacks,
                 deliver: async (payload, info) => {
+                    logDebug("sider dispatch deliver payload", {
+                        accountId: account.accountId,
+                        sessionId,
+                        kind: info.kind,
+                        hasText: typeof payload.text === "string" && payload.text.length > 0,
+                        mediaCount: resolveOutboundMediaUrls(payload).length,
+                    });
                     await deliverReplyPayloadToSider({
                         account,
                         sessionId,
@@ -894,9 +1273,28 @@ async function handleInboundRealtimeMessage(params) {
                 },
             },
             replyOptions: {
+                disableBlockStreaming: false,
+                onPartialReply: async (payload) => {
+                    const snapshot = typeof payload.text === "string" ? payload.text : "";
+                    if (!snapshot) {
+                        return;
+                    }
+                    await enqueueStreamEventTask({
+                        streamState,
+                        task: async () => {
+                            await handleStreamingPartialSnapshot({
+                                account,
+                                sessionId,
+                                streamState,
+                                snapshot,
+                            });
+                        },
+                    });
+                },
                 onModelSelected,
             },
         });
+        dispatchCompleted = true;
         logDebug("completed sider inbound dispatch", {
             accountId: account.accountId,
             sessionId,
@@ -904,25 +1302,39 @@ async function handleInboundRealtimeMessage(params) {
         });
     }
     finally {
-        if (streamState.active && streamState.streamId) {
-            streamState.seq += 1;
-            const streamDoneEvent = buildStreamingDoneEvent({
-                sessionId,
-                streamId: streamState.streamId,
-                seq: streamState.seq,
-                accountId: account.accountId,
-                reason: "interrupted",
-            });
-            await sendSiderEventBestEffort({
-                account,
-                sessionId,
-                event: streamDoneEvent,
-                context: "stream.done.interrupted",
-            });
-            streamState.active = false;
-            streamState.streamId = undefined;
-            streamState.seq = 0;
-        }
+        await flushStreamEventQueue(streamState);
+        await closeStreamingSessionIfActive({
+            account,
+            sessionId,
+            streamState,
+            reason: dispatchCompleted ? "final" : "interrupted",
+            context: dispatchCompleted ? "stream.done.dispatch-end" : "stream.done.interrupted",
+        });
+        streamState.blockDeltaCount = 0;
+    }
+    if (!dispatchCompleted) {
+        return;
+    }
+    if (!streamState.persistedFinalText && streamState.accumulatedBlockText.trim()) {
+        const text = streamState.accumulatedBlockText;
+        logDebug("no final message payload observed; persisting accumulated block text as final message", {
+            accountId: account.accountId,
+            sessionId,
+            textLength: text.length,
+        });
+        await sendMessageToSider({
+            account,
+            sessionId,
+            parts: [
+                {
+                    type: "core.text",
+                    spec_version: 1,
+                    payload: { text },
+                },
+            ],
+        });
+        streamState.persistedFinalText = true;
+        streamState.accumulatedBlockText = "";
     }
 }
 async function handleInboundRealtimeEvent(params) {
@@ -1153,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`);
@@ -1161,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");
@@ -1197,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