@jack200714/mafw 4.5.1

package/gateway/dist/media/media-agent.js

@@ -0,0 +1,755 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaAgent = exports.MAX_IMAGE_BYTES = exports.MAX_AUDIO_BYTES = exports.MAX_VIDEO_BYTES = exports.MEDIA_TASK_PREFIX = exports.ARTIFACT_SCHEME = void 0;
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const server_1 = require("@a2a-js/sdk/server");
+const sdk_1 = require("@a2a-js/sdk");
+const errors_1 = require("@a2a-js/sdk/errors");
+const sdk_2 = require("@a2a-js/sdk");
+const media_service_1 = require("./media-service");
+const logger_1 = require("../core/utils/logger");
+/**
+ * MediaAgent — an A2A (Agent2Agent) v1.0 agent that answers multi-turn
+ * questions about image / video / audio media via the configured multimodal
+ * API (MediaService). Each modality can use its own model (media 配置段).
+ *
+ * Protocol surface (all standard A2A, JSON-RPC binding):
+ *   message/send   — first turn carries the media as a FilePart (raw bytes);
+ *                    follow-ups carry text only, the task keeps the media.
+ *   tasks/get, tasks/cancel, tasks/list
+ *   Agent card     — GET /.well-known/agent-card.json
+ *   Artifacts      — task outputs (the stored media) exposed via artifact URL,
+ *                    per spec §6.7 output-reference pattern.
+ *
+ * Internals:
+ *   - ArtifactStore: LRU(500) + TTL(24h) map of media bytes (data URLs).
+ *   - The media is stored once as a task artifact; revive flows (new task
+ *     after the old one completed) reference the old artifact via its URL,
+ *     so the bytes are never re-uploaded.
+ *   - messageId idempotency: a repeated messageId on the same task returns
+ *     the current task without re-running the media model.
+ */
+exports.ARTIFACT_SCHEME = 'mafw-artifact://';
+exports.MEDIA_TASK_PREFIX = 'mtask_';
+// Bytes above this threshold are written to a temp file instead of being kept
+// as a base64 string in memory (50MB video → ~67MB string otherwise).
+const DISK_THRESHOLD_BYTES = 5 * 1024 * 1024;
+class ArtifactStore {
+    max;
+    ttlMs;
+    now;
+    map = new Map();
+    index = new Map();
+    storageDir;
+    indexPath;
+    constructor(storageDir, max = 500, ttlMs = 24 * 60 * 60 * 1000, now = Date.now) {
+        this.max = max;
+        this.ttlMs = ttlMs;
+        this.now = now;
+        this.storageDir = storageDir || path.join(os.tmpdir(), 'mafw-media');
+        this.indexPath = path.join(this.storageDir, 'artifacts.json');
+        if (!fs.existsSync(this.storageDir))
+            fs.mkdirSync(this.storageDir, { recursive: true });
+        this.loadIndex();
+    }
+    loadIndex() {
+        try {
+            if (fs.existsSync(this.indexPath)) {
+                const raw = fs.readFileSync(this.indexPath, 'utf-8');
+                const entries = JSON.parse(raw);
+                const now = this.now();
+                for (const entry of entries) {
+                    if (now - entry.createdAt > this.ttlMs)
+                        continue; // expired
+                    const filePath = path.join(this.storageDir, entry.filename);
+                    if (!fs.existsSync(filePath))
+                        continue; // file missing
+                    this.index.set(entry.id, entry);
+                    this.map.set(entry.id, {
+                        dataUrl: null,
+                        bytes: null,
+                        filePath,
+                        mediaType: entry.mediaType,
+                        size: entry.size,
+                        createdAt: entry.createdAt,
+                    });
+                }
+                logger_1.log.info(`[ArtifactStore] loaded ${this.map.size} artifacts from disk`);
+            }
+        }
+        catch (err) {
+            logger_1.log.warn(`[ArtifactStore] failed to load index: ${err.message}`);
+        }
+    }
+    saveIndex() {
+        try {
+            const entries = [];
+            for (const [id, entry] of this.map) {
+                if (!entry.filePath)
+                    continue; // skip in-memory-only entries
+                entries.push({
+                    id,
+                    mediaType: entry.mediaType,
+                    size: entry.size,
+                    createdAt: entry.createdAt,
+                    filename: path.basename(entry.filePath),
+                });
+            }
+            fs.writeFileSync(this.indexPath, JSON.stringify(entries, null, 2));
+        }
+        catch (err) {
+            logger_1.log.warn(`[ArtifactStore] failed to save index: ${err.message}`);
+        }
+    }
+    put(dataUrl) {
+        return this.putBytes(Buffer.from(dataUrl.slice(dataUrl.indexOf(',') + 1), 'base64'), this.mediaTypeFromDataUrl(dataUrl));
+    }
+    /** Store raw bytes to disk (persistent across restarts). */
+    putBytes(bytes, mediaType) {
+        this.prune();
+        const id = (0, crypto_1.randomUUID)();
+        const createdAt = this.now();
+        const ext = mediaType.split('/')[1]?.split(';')[0] || 'bin';
+        const filename = `${id}.${ext}`;
+        const filePath = path.join(this.storageDir, filename);
+        try {
+            fs.writeFileSync(filePath, bytes);
+        }
+        catch (err) {
+            logger_1.log.warn(`[ArtifactStore] disk write failed, using memory fallback: ${err.message}`);
+            const dataUrl = `data:${mediaType || 'application/octet-stream'};base64,${bytes.toString('base64')}`;
+            this.map.set(id, { dataUrl, bytes, filePath: null, mediaType, size: bytes.length, createdAt });
+            if (this.map.size > this.max) {
+                const oldest = this.map.keys().next().value;
+                if (oldest !== undefined)
+                    this.delete(oldest);
+            }
+            return id;
+        }
+        this.map.set(id, { dataUrl: null, bytes: null, filePath, mediaType, size: bytes.length, createdAt });
+        if (this.map.size > this.max) {
+            const oldest = this.map.keys().next().value;
+            if (oldest !== undefined)
+                this.delete(oldest);
+        }
+        this.saveIndex();
+        return id;
+    }
+    /** Return the artifact as a data URL (reads from disk). */
+    get(id) {
+        const entry = this.map.get(id);
+        if (!entry)
+            return undefined;
+        if (this.now() - entry.createdAt > this.ttlMs) {
+            this.delete(id);
+            return undefined;
+        }
+        // LRU touch
+        this.map.delete(id);
+        this.map.set(id, entry);
+        if (entry.dataUrl)
+            return entry.dataUrl;
+        if (entry.filePath) {
+            try {
+                const buf = fs.readFileSync(entry.filePath);
+                return `data:${entry.mediaType || 'application/octet-stream'};base64,${buf.toString('base64')}`;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    getMediaType(id) {
+        return this.map.get(id)?.mediaType;
+    }
+    size() {
+        return this.map.size;
+    }
+    delete(id) {
+        const entry = this.map.get(id);
+        this.map.delete(id);
+        this.index.delete(id);
+        if (entry?.filePath) {
+            try {
+                fs.unlinkSync(entry.filePath);
+            }
+            catch { /* ignore */ }
+        }
+        this.saveIndex();
+    }
+    prune() {
+        const now = this.now();
+        let pruned = false;
+        for (const [id, entry] of this.map) {
+            if (now - entry.createdAt > this.ttlMs) {
+                this.map.delete(id);
+                this.index.delete(id);
+                if (entry?.filePath) {
+                    try {
+                        fs.unlinkSync(entry.filePath);
+                    }
+                    catch { /* ignore */ }
+                }
+                pruned = true;
+            }
+        }
+        if (pruned)
+            this.saveIndex();
+    }
+    mediaTypeFromDataUrl(dataUrl) {
+        const m = dataUrl.match(/^data:([^;,]+)/);
+        return m ? m[1] : 'application/octet-stream';
+    }
+}
+const SUPPORTED_INPUT_MODES = ['text', 'image', 'video', 'audio'];
+// Size guards: base64 data-URL character length → raw bytes ≈ len * 0.75.
+// Video is expensive to ship around and to encode; cap both conservatively.
+exports.MAX_VIDEO_BYTES = 50 * 1024 * 1024;
+exports.MAX_AUDIO_BYTES = 25 * 1024 * 1024;
+exports.MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+function taskStatus(state, message, timestamp = new Date().toISOString()) {
+    return { state, timestamp, message };
+}
+function textPart(text) {
+    return {
+        content: { $case: 'text', value: text },
+        mediaType: 'text/plain',
+        filename: '',
+        metadata: {},
+    };
+}
+function makeMessage(role, taskId, contextId, parts) {
+    return {
+        role,
+        messageId: (0, crypto_1.randomUUID)(),
+        taskId,
+        contextId,
+        parts,
+        metadata: {},
+        extensions: [],
+        referenceTaskIds: [],
+    };
+}
+class MediaAgent {
+    media;
+    options;
+    artifacts;
+    taskStore;
+    jsonRpc;
+    handler;
+    agentCardData;
+    seenMessages = new Map();
+    constructor(media, options) {
+        this.media = media;
+        this.options = options;
+        this.artifacts = new ArtifactStore(options.storageDir);
+        this.taskStore = new server_1.InMemoryTaskStore();
+        this.agentCardData = this.buildAgentCard();
+        const executor = {
+            execute: (ctx, bus) => this.execute(ctx, bus),
+            cancelTask: async (taskId, bus) => this.cancelTask(taskId, bus),
+        };
+        this.handler = new server_1.DefaultRequestHandler(this.agentCardData, this.taskStore, executor);
+        this.jsonRpc = new server_1.JsonRpcTransportHandler(this.handler);
+        logger_1.log.info(`[MediaAgent] A2A agent ready at ${options.baseUrl}/a2a`);
+    }
+    get agentCard() {
+        return this.agentCardData;
+    }
+    artifactCount() {
+        return this.artifacts.size();
+    }
+    getArtifact(id) {
+        const dataUrl = this.artifacts.get(id);
+        if (!dataUrl)
+            return undefined;
+        const mime = dataUrl.match(/^data:([^;]+);/)?.[1] || 'application/octet-stream';
+        return { dataUrl, mediaType: mime };
+    }
+    /** 存入 artifact（TTS 输出等 gateway 侧产物），返回 artifact ID。mime 从 dataUrl 前缀推导。 */
+    putArtifact(dataUrl) {
+        return this.artifacts.put(dataUrl);
+    }
+    /** 存入原始媒体字节（桌面端二进制上传），大文件落盘。 */
+    putArtifactBytes(bytes, mediaType) {
+        return this.artifacts.putBytes(bytes, mediaType);
+    }
+    getArtifactMediaType(id) {
+        return this.artifacts.getMediaType(id);
+    }
+    async resolveTaskArtifactId(taskId) {
+        try {
+            const task = await this.taskStore.load(taskId, {});
+            if (!task?.artifacts?.length)
+                return undefined;
+            return task.artifacts[0]?.artifactId;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Create a task immediately and start analysis in the background.
+     * Returns the task ID synchronously; analysis runs asynchronously.
+     */
+    createTaskAsync(artifactId, mediaType, question) {
+        const t0 = Date.now();
+        const taskId = `mtask_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        const contextId = `mctx_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        // Build artifact reference upfront so follow-up SendMessage (via
+        // referenceTaskIds) can find the media immediately, even before the
+        // background analysis completes.
+        const artifactUrl = `${this.options.baseUrl}${this.options.artifactPath}/${artifactId}`;
+        const artifact = {
+            artifactId,
+            name: 'upload.bin',
+            description: '原始媒体工件',
+            parts: [
+                {
+                    content: { $case: 'url', value: artifactUrl },
+                    mediaType,
+                    filename: 'upload.bin',
+                    metadata: {},
+                },
+            ],
+            metadata: {},
+            extensions: [],
+        };
+        // Create task in store (state=working) with artifact already set
+        const task = {
+            id: taskId,
+            contextId,
+            status: taskStatus(sdk_1.TaskState.TASK_STATE_WORKING),
+            history: [],
+            artifacts: [artifact],
+            metadata: {},
+        };
+        // Save task synchronously (use same context as SendMessage handler)
+        const saveContext = new server_1.ServerCallContext({
+            headers: {},
+            requestedVersion: this.options.defaultVersion || '1.0',
+            user: new server_1.UnauthenticatedUser(),
+            extensions: undefined,
+        });
+        this.taskStore.save(task, saveContext).catch(err => {
+            logger_1.log.error(`[MediaAgent] createTaskAsync: failed to save task ${taskId}: ${err.message}`);
+        });
+        // Build message with correct A2A part format: content.$case = 'url'
+        const mediaPart = {
+            content: { $case: 'url', value: artifactUrl },
+            mediaType,
+            filename: 'upload.bin',
+            metadata: {},
+        };
+        const userMessage = makeMessage(1, taskId, contextId, [
+            mediaPart,
+            ...(question ? [textPart(question)] : []),
+        ]);
+        // Trigger async analysis in background
+        const requestContext = {
+            taskId,
+            contextId,
+            userMessage,
+            task, // pass the task with its artifact so execute's working-state publish
+            // does not clobber artifacts with an empty array
+            referenceTasks: [],
+        };
+        // Simple event bus that updates task store (same context as the initial save)
+        const bus = {
+            publish: (event) => {
+                if (event.kind === 'task') {
+                    this.taskStore.save(event.data, saveContext).catch(err => {
+                        logger_1.log.error(`[MediaAgent] createTaskAsync: failed to update task ${taskId}: ${err.message}`);
+                    });
+                }
+            },
+            on: () => bus,
+            off: () => bus,
+            once: () => bus,
+            removeAllListeners: () => bus,
+            finished: () => { },
+        };
+        const t1 = Date.now();
+        console.log(`[MediaAgent] createTaskAsync: prep ${t1 - t0}ms, starting background analysis for task ${taskId}`);
+        // Fire-and-forget: execute analysis in background (don't wait)
+        void this.execute(requestContext, bus).then(() => {
+            const t2 = Date.now();
+            console.log(`[MediaAgent] createTaskAsync: analysis completed for task ${taskId} in ${t2 - t1}ms`);
+        }).catch(err => {
+            console.error(`[MediaAgent] createTaskAsync: analysis failed for task ${taskId}: ${err.message}`);
+        });
+        return { taskId, contextId };
+    }
+    /**
+     * Handle a JSON-RPC A2A request (POST /a2a). Returns the HTTP response.
+     */
+    async handleJsonRpc(body, headers) {
+        // 诊断：打印 SendMessage 收到的 parts 原始结构（定位桌面 createTask 失败根因）
+        try {
+            const rawBody = typeof body === 'string' ? JSON.parse(body) : body;
+            const msg = rawBody?.params?.message;
+            if (rawBody?.method === 'SendMessage' && Array.isArray(msg?.parts)) {
+                logger_1.log.info(`[MediaAgent] SendMessage parts: ${JSON.stringify(msg.parts).slice(0, 400)} | ` +
+                    `msgId=${String(msg?.messageId ?? '').slice(0, 24)} hasRef=${Array.isArray(msg?.referenceTaskIds) ? msg.referenceTaskIds.length : 0}`);
+            }
+        }
+        catch { /* 诊断日志失败不影响主流程 */ }
+        const requestedVersion = headers[sdk_2.A2A_VERSION_HEADER?.toLowerCase()] || this.options.defaultVersion || '1.0';
+        const context = new server_1.ServerCallContext({
+            headers,
+            requestedVersion,
+            user: new server_1.UnauthenticatedUser(),
+            extensions: undefined,
+        });
+        const result = await this.jsonRpc.handle(body, context);
+        if (typeof result?.[Symbol.asyncIterator] === 'function') {
+            // Streaming response (message/stream) — collect the first event for the
+            // internal synchronous path; the gateway does not expose streaming yet.
+            const generator = result;
+            const first = await generator.next();
+            if (first.done) {
+                return { status: 200, headers: { [sdk_2.A2A_VERSION_HEADER]: '1.0' }, body: JSON.stringify({ jsonrpc: '2.0', result: null }) };
+            }
+            return { status: 200, headers: { [sdk_2.A2A_VERSION_HEADER]: '1.0' }, body: JSON.stringify(first.value) };
+        }
+        return {
+            status: 200,
+            headers: { [sdk_2.A2A_VERSION_HEADER]: '1.0', 'Content-Type': 'application/a2a+json' },
+            body: JSON.stringify(result),
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Executor
+    async execute(requestContext, bus) {
+        const taskId = requestContext.taskId;
+        const contextId = requestContext.contextId;
+        const userMessage = requestContext.userMessage;
+        console.log(`[MediaAgent] execute called: taskId=${taskId}, contextId=${contextId}, userMessageId=${userMessage.messageId}`);
+        logger_1.log.info(`[MediaAgent] execute called: taskId=${taskId}, contextId=${contextId}, userMessageId=${userMessage.messageId}`);
+        // Idempotency: a message already processed for this task is a replay.
+        const seen = this.seenMessages.get(taskId) ?? new Set();
+        if (requestContext.task && seen.has(userMessage.messageId)) {
+            logger_1.log.info(`[MediaAgent] execute: replay detected, returning cached task`);
+            bus.publish(server_1.AgentEvent.task(requestContext.task));
+            return;
+        }
+        seen.add(userMessage.messageId);
+        this.seenMessages.set(taskId, seen);
+        // Working state on entry.
+        const workingTask = requestContext.task ?? {
+            id: taskId,
+            contextId,
+            status: taskStatus(sdk_1.TaskState.TASK_STATE_SUBMITTED),
+            history: [],
+            artifacts: [],
+            metadata: {},
+        };
+        workingTask.status = taskStatus(sdk_1.TaskState.TASK_STATE_WORKING);
+        bus.publish(server_1.AgentEvent.task(workingTask));
+        try {
+            // Resolve the media: first turn extracts it from the message parts;
+            // follow-up turns reference the prior task (referenceTaskIds) and reuse
+            // its artifact — the bytes are never re-uploaded.
+            logger_1.log.info(`[MediaAgent] execute: taskId=${taskId}, referenceTasks=${requestContext.referenceTasks?.length ?? 0}, hasTask=${!!requestContext.task}`);
+            if (requestContext.referenceTasks && requestContext.referenceTasks.length > 0) {
+                for (const rt of requestContext.referenceTasks) {
+                    logger_1.log.info(`[MediaAgent] execute: refTask ${rt.id}, artifacts=${rt.artifacts?.length ?? 0}`);
+                }
+            }
+            const media = await this.resolveMedia(requestContext, userMessage);
+            if (!media) {
+                throw new errors_1.ContentTypeNotSupportedError('A2A media agent requires an image/video/audio part (raw bytes or a known artifact URL) on the first message.');
+            }
+            const kind = (0, media_service_1.kindFromMediaType)(media.mediaType);
+            // Build the prompt from referenced/history context + the new question.
+            const priorTasks = requestContext.referenceTasks ?? [];
+            const historyText = this.historyToText([...priorTasks.flatMap((t) => t.history ?? []), ...(requestContext.task?.history ?? [])]);
+            const questionText = this.messageToText(userMessage);
+            // 音频首轮（无历史上下文）→ 叙述式分析（内容 + 情绪/语调轨迹 + 意图，自然语言）；
+            // 追问轮保持自由提问（主 Agent 可追问细节）。
+            if (kind === 'audio' && !historyText) {
+                const description = await this.media.analyzeAudioNarrative({
+                    kind,
+                    dataUrl: media.dataUrl,
+                    mediaType: media.mediaType,
+                });
+                const answerMessage = makeMessage(2, taskId, contextId, [textPart(description)]);
+                const history = [...(requestContext.task?.history ?? []), userMessage, answerMessage];
+                const artifact = media.artifact;
+                const finalTask = {
+                    id: taskId,
+                    contextId,
+                    status: taskStatus(sdk_1.TaskState.TASK_STATE_COMPLETED, answerMessage),
+                    history,
+                    artifacts: artifact ? [artifact] : requestContext.task?.artifacts ?? [],
+                    metadata: {},
+                };
+                bus.publish(server_1.AgentEvent.task(finalTask));
+                return;
+            }
+            const prompt = [historyText, questionText].filter(Boolean).join('\n\n') || '请描述这个媒体内容。';
+            const description = await this.media.analyze({ kind, dataUrl: media.dataUrl, mediaType: media.mediaType }, prompt);
+            const answerMessage = makeMessage(2, taskId, contextId, [textPart(description)]);
+            const history = [...(requestContext.task?.history ?? []), userMessage, answerMessage];
+            const artifact = media.artifact;
+            const finalTask = {
+                id: taskId,
+                contextId,
+                status: taskStatus(sdk_1.TaskState.TASK_STATE_COMPLETED, answerMessage),
+                history,
+                artifacts: artifact ? [artifact] : requestContext.task?.artifacts ?? [],
+                metadata: {},
+            };
+            bus.publish(server_1.AgentEvent.task(finalTask));
+        }
+        catch (err) {
+            logger_1.log.error(`[MediaAgent] task ${taskId} failed: ${err.message}`);
+            const errorMessage = makeMessage(2, taskId, contextId, [textPart(`[media agent] 媒体分析失败：${err.message}`)]);
+            const failedTask = {
+                id: taskId,
+                contextId,
+                status: taskStatus(sdk_1.TaskState.TASK_STATE_FAILED, errorMessage),
+                history: [...(requestContext.task?.history ?? []), userMessage],
+                artifacts: requestContext.task?.artifacts ?? [],
+                metadata: {},
+            };
+            bus.publish(server_1.AgentEvent.task(failedTask));
+        }
+    }
+    async cancelTask(taskId, bus) {
+        const task = await this.taskStore.load(taskId, {});
+        if (!task)
+            throw new errors_1.TaskNotFoundError(`Task ${taskId} not found`);
+        const canceled = {
+            ...task,
+            status: taskStatus(sdk_1.TaskState.TASK_STATE_CANCELED),
+        };
+        bus.publish(server_1.AgentEvent.task(canceled));
+        // fail-open：中止进行中的媒体分析（executor.cancelInflight）
+        try {
+            await this.options.cancelHook?.(taskId);
+        }
+        catch { /* ignore */ }
+    }
+    // -------------------------------------------------------------------------
+    // Media resolution
+    async resolveMedia(requestContext, userMessage) {
+        // Follow-up turn: reuse the media artifact of a referenced prior task.
+        const refTasks = requestContext.referenceTasks ?? [];
+        logger_1.log.info(`[MediaAgent] resolveMedia: referenceTasks=${refTasks.length}, hasTask=${!!requestContext.task}`);
+        for (const refTask of refTasks) {
+            logger_1.log.info(`[MediaAgent] resolveMedia: checking refTask ${refTask.id}, artifacts=${refTask.artifacts?.length ?? 0}`);
+            const media = this.mediaFromTask(refTask);
+            if (media) {
+                logger_1.log.info(`[MediaAgent] resolveMedia: found media from refTask ${refTask.id}`);
+                return media;
+            }
+        }
+        // Or from the current task (e.g. resumed history).
+        if (requestContext.task) {
+            logger_1.log.info(`[MediaAgent] resolveMedia: checking current task ${requestContext.task.id}, artifacts=${requestContext.task.artifacts?.length ?? 0}`);
+            const media = this.mediaFromTask(requestContext.task);
+            if (media) {
+                logger_1.log.info(`[MediaAgent] resolveMedia: found media from current task`);
+                return media;
+            }
+        }
+        // First turn: extract from the message parts.
+        const mediaPart = userMessage.parts.find((p) => p.content?.$case === 'raw' || p.content?.$case === 'url');
+        if (!mediaPart)
+            return undefined;
+        const mediaType = mediaPart.mediaType || (mediaPart.content?.$case === 'raw' ? 'application/octet-stream' : '');
+        if (!mediaType.startsWith('image/') && !mediaType.startsWith('video/') && !mediaType.startsWith('audio/')) {
+            throw new errors_1.ContentTypeNotSupportedError(`Unsupported media type: ${mediaType || 'unknown'}`);
+        }
+        if (mediaPart.content?.$case === 'raw') {
+            const raw = mediaPart.content.value;
+            // The SDK may deliver raw bytes as a Buffer or as a Uint8Array/number[] —
+            // normalize before re-encoding to base64.
+            const bytes = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+            this.assertSize(mediaType, bytes.length);
+            const dataUrl = `data:${mediaType};base64,${bytes.toString('base64')}`;
+            const artifactId = this.artifacts.put(dataUrl);
+            const artifactUrl = `${this.options.baseUrl}${this.options.artifactPath}/${artifactId}`;
+            return {
+                dataUrl,
+                mediaType,
+                artifact: {
+                    artifactId,
+                    name: mediaPart.filename || this.defaultMediaName(mediaType),
+                    description: '原始媒体工件',
+                    parts: [
+                        {
+                            content: { $case: 'url', value: artifactUrl },
+                            mediaType,
+                            filename: mediaPart.filename || this.defaultMediaName(mediaType),
+                            metadata: {},
+                        },
+                    ],
+                    metadata: {},
+                },
+            };
+        }
+        // url part — only our own artifact URLs are accepted (SSRF protection).
+        if (mediaPart.content?.$case !== 'url')
+            return undefined;
+        const url = mediaPart.content.value;
+        const id = this.artifactUrlToId(url) ?? (url.startsWith(exports.ARTIFACT_SCHEME) ? url.slice(exports.ARTIFACT_SCHEME.length) : undefined);
+        const dataUrl = id ? this.artifacts.get(id) : undefined;
+        if (!dataUrl) {
+            // 诊断：区分 artifact 内存丢失（upload 后 gateway 重启/TTL 淘汰）与解析失败
+            logger_1.log.warn(`[MediaAgent] artifact url part unresolvable | url=${url} id=${id ?? '(none)'} ` +
+                `storeSize=${this.artifacts.size()} storeHas=${id ? this.artifacts.get(id) !== undefined : 'n/a'}`);
+            throw new errors_1.ContentTypeNotSupportedError('外部媒体 URL 不被接受；请使用 raw 字节或本 agent 的工件引用。');
+        }
+        const mime = dataUrl.match(/^data:([^;]+);/)?.[1] || 'application/octet-stream';
+        // 与 raw 分支一致：把工件挂到任务 artifacts，追问轮（referenceTaskIds）才能
+        // 经 mediaFromTask 复用媒体——否则首轮成功后 artifacts 为空，追问必败。
+        const artifactUrl = `${this.options.baseUrl}${this.options.artifactPath}/${id}`;
+        return {
+            dataUrl,
+            mediaType: mime,
+            artifact: {
+                artifactId: id,
+                name: mediaPart.filename || this.defaultMediaName(mime),
+                description: '原始媒体工件',
+                parts: [
+                    {
+                        content: { $case: 'url', value: artifactUrl },
+                        mediaType: mime,
+                        filename: mediaPart.filename || this.defaultMediaName(mime),
+                        metadata: {},
+                    },
+                ],
+                metadata: {},
+            },
+        };
+    }
+    mediaFromTask(task) {
+        const urlPart = task.artifacts
+            ?.flatMap((a) => a.parts ?? [])
+            .find((p) => p.content?.$case === 'url');
+        if (!urlPart)
+            return undefined;
+        const id = this.artifactUrlToId(String(urlPart.content.value));
+        const dataUrl = id ? this.artifacts.get(id) : undefined;
+        if (!dataUrl)
+            return undefined;
+        const mime = dataUrl.match(/^data:([^;]+);/)?.[1] || 'application/octet-stream';
+        return { dataUrl, mediaType: mime };
+    }
+    assertSize(mediaType, byteLength) {
+        let max;
+        if (mediaType.startsWith('video/'))
+            max = exports.MAX_VIDEO_BYTES;
+        else if (mediaType.startsWith('audio/'))
+            max = exports.MAX_AUDIO_BYTES;
+        else
+            max = exports.MAX_IMAGE_BYTES;
+        if (byteLength > max) {
+            throw new errors_1.ContentTypeNotSupportedError(`媒体过大：${(byteLength / (1024 * 1024)).toFixed(1)}MB 超过上限 ${(max / (1024 * 1024)).toFixed(0)}MB（${mediaType}）`);
+        }
+    }
+    defaultMediaName(mediaType) {
+        const ext = (mediaType.split('/')[1] || 'bin').split(';')[0].split('+')[0];
+        return `media.${ext || 'bin'}`;
+    }
+    artifactUrlToId(url) {
+        const marker = `${this.options.artifactPath}/`;
+        const idx = url.lastIndexOf(marker);
+        if (idx < 0)
+            return undefined;
+        const id = url.slice(idx + marker.length).split(/[?#]/)[0];
+        return id || undefined;
+    }
+    // -------------------------------------------------------------------------
+    // Text helpers
+    messageToText(message) {
+        return message.parts
+            .filter((p) => p.content?.$case === 'text')
+            .map((p) => String(p.content.value))
+            .join('\n')
+            .trim();
+    }
+    historyToText(history) {
+        return history
+            .map((m) => {
+            const role = m.role === 1 ? '用户' : '媒体Agent';
+            const text = this.messageToText(m);
+            return text ? `${role}: ${text}` : '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    // -------------------------------------------------------------------------
+    // Agent card
+    buildAgentCard() {
+        const skill = {
+            id: 'media_analyze',
+            name: 'media_analyze',
+            description: '分析图片/视频/音频并回答关于媒体的多轮问题。首次消息需包含媒体（FilePart raw 字节或工件 URL 引用），后续消息只发送文本问题即可，媒体会保留在任务上下文中。',
+            tags: ['media', 'image', 'video', 'audio', 'multimodal'],
+            examples: [],
+            inputModes: SUPPORTED_INPUT_MODES,
+            outputModes: ['text'],
+            securityRequirements: [],
+        };
+        return {
+            name: 'MAFW MediaAgent',
+            description: 'MAFW 内置多模态 Agent：基于 gateway media 配置段（默认 xiaomi/mimo-v2.5，每模态可独立指定 provider/model）对图片、视频、音频进行多轮问答分析。',
+            url: `${this.options.baseUrl}/a2a`,
+            version: '1.0.0',
+            provider: { url: this.options.baseUrl, organization: 'MAFW' },
+            capabilities: {
+                streaming: false,
+                pushNotifications: false,
+                extensions: [],
+            },
+            defaultInputModes: SUPPORTED_INPUT_MODES,
+            defaultOutputModes: ['text'],
+            skills: [skill],
+            supportedInterfaces: [],
+            securitySchemes: {},
+            securityRequirements: [],
+            signatures: [],
+        };
+    }
+}
+exports.MediaAgent = MediaAgent;