@ixo/oracle-runtime-workers 0.2.0

package/src/attachments/pipeline.ts

@@ -0,0 +1,409 @@
+/**
+ * Turn-time attachment handling — the port of the Node runtime's
+ * `MessagesService` attachment section plus `FileProcessingService.
+ * processAttachments`:
+ *
+ *  1. classify + route each attachment by the selected model's native input
+ *     capabilities (`send-native` / `parse-local` / `model-extract`);
+ *  2. NATIVE lane: download, sniff, base64 into LangChain content blocks on
+ *     the human message (cumulative 50 MB budget; any failure or budget
+ *     overflow falls that file back to extraction so a bad download never
+ *     drops the whole message); the original is archived to the sandbox in
+ *     the background;
+ *  3. EXTRACT lane: sequential (so the running download total is enforced
+ *     before the next fetch), plain text read locally, everything else
+ *     described / transcribed / extracted by the helper model, then archived
+ *     to the sandbox — when the archive succeeds the text handed to the model
+ *     is truncated to 500 chars and points at the sandbox copy (the agent's
+ *     file tools read the rest), exactly as on Node;
+ *  4. every attachment's metadata lands on the human message so transcripts
+ *     render file chips regardless of which lane consumed it.
+ */
+import type { MessageContent } from '@langchain/core/messages';
+import type { ModelInputCapabilities } from '../core/llm';
+import { bytesToBase64 } from '../plugins/base64';
+import type { Logger } from '../plugin-api/types';
+import type { AttachmentMeta } from '../sqlite/serialization';
+import { classifyAttachment } from './classify';
+import {
+  buildUserMessageContent,
+  type NativeAttachment,
+} from './content-blocks';
+import {
+  ALLOWED_URI_SCHEMES,
+  loadAttachmentBytes,
+  MAX_FILE_SIZE,
+  MAX_TOTAL_SIZE,
+  type MatrixMediaSource,
+} from './download';
+import {
+  aiProcessFromUrl,
+  extractText,
+  formatContent,
+  type ExtractionProvider,
+  type ExtractionUsage,
+} from './extract';
+import { categorizeFile, verifyMagicBytes, type FileCategory } from './magic';
+import { routeAttachment } from './route';
+import {
+  buildAnalysisMarkdown,
+  uploadToSandbox,
+  type SandboxUploadConfig,
+} from './sandbox-archive';
+import {
+  sanitizeAttachmentFilename,
+  sanitizeSandboxPath,
+  SANDBOX_OUTPUT_PREFIX,
+} from './sanitize';
+import type { AttachmentInput } from './types';
+
+/** Node's `SANDBOX_TRUNCATE_LIMIT`: what the model sees inline once the file is archived. */
+export const SANDBOX_TRUNCATE_LIMIT = 500;
+
+export interface AttachmentPipelineDeps {
+  source: MatrixMediaSource;
+  /** Helper-model provider for the extract lane; null → media cannot be extracted here. */
+  extraction: ExtractionProvider | null;
+  /** Sandbox archive target; null → originals are not archived (logged once per turn). */
+  sandbox: SandboxUploadConfig | null;
+  fetchImpl?: typeof fetch;
+  signal?: AbortSignal;
+  logger: Logger;
+}
+
+export interface ExtractedAttachment {
+  /** Model-facing text, prefixed with a `[source: …]` reference like Node's. */
+  text: string;
+  meta: AttachmentMeta;
+}
+
+export interface PreparedAttachments {
+  /** The human message content: the text, plus native blocks when any. */
+  content: MessageContent;
+  /** Metadata for every attachment, in request order (chips in transcripts). */
+  metas: AttachmentMeta[];
+  /** Extraction-lane results, to append as hidden context messages. */
+  extracted: ExtractedAttachment[];
+  usage: { cost: number; promptTokens: number; completionTokens: number };
+}
+
+export interface PrepareAttachmentsParams {
+  text: string;
+  attachments: AttachmentInput[];
+  /** Room for `eventId` downloads (the user↔oracle room, or the Matrix room the turn came from). */
+  roomId?: string;
+  /** The model the turn will run on and its native input capabilities. */
+  model: string;
+  caps: ModelInputCapabilities;
+}
+
+function metaFor(attachment: AttachmentInput): AttachmentMeta {
+  return {
+    filename: attachment.filename,
+    mimetype: attachment.mimetype,
+    ...(attachment.size !== undefined ? { size: attachment.size } : {}),
+    ...(attachment.mxcUri ? { mxcUri: attachment.mxcUri } : {}),
+    ...(attachment.eventId ? { eventId: attachment.eventId } : {}),
+    category: classifyAttachment(attachment),
+  };
+}
+
+function sourceRef(attachment: AttachmentInput): string {
+  if (attachment.eventId) return `[source: eventId="${attachment.eventId}"]`;
+  if (attachment.mxcUri) return `[source: url="${attachment.mxcUri}"]`;
+  return '';
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/** One attachment through the extract lane (Node's `processAttachment`). */
+async function extractOne(
+  attachment: AttachmentInput,
+  currentTotal: number,
+  params: PrepareAttachmentsParams,
+  deps: AttachmentPipelineDeps,
+): Promise<{ text: string; downloaded: number; usage?: ExtractionUsage }> {
+  const safeName = sanitizeAttachmentFilename(attachment.filename);
+  if (!attachment.eventId && !attachment.mxcUri)
+    throw new Error('Either mxcUri or eventId must be provided');
+  if (attachment.mxcUri && !ALLOWED_URI_SCHEMES.test(attachment.mxcUri))
+    throw new Error('Invalid URI scheme');
+  if (attachment.size && attachment.size > MAX_FILE_SIZE)
+    throw new Error('File exceeds maximum size');
+  if (attachment.size && currentTotal + attachment.size > MAX_TOTAL_SIZE)
+    throw new Error('Total attachment size budget exceeded');
+
+  const category: FileCategory = categorizeFile(attachment.mimetype);
+  if (category === 'unsupported') {
+    deps.logger.warn(
+      `[attachments] unsupported file type ${attachment.mimetype} for ${attachment.filename}`,
+    );
+    return {
+      text: `[File "${safeName}" (${attachment.mimetype}) is not a supported file type and could not be processed]`,
+      downloaded: 0,
+    };
+  }
+
+  const { bytes } = await loadAttachmentBytes(
+    attachment,
+    params.roomId,
+    deps.source,
+    { fetchImpl: deps.fetchImpl, signal: deps.signal },
+  );
+  verifyMagicBytes(bytes, category, attachment, (m) =>
+    deps.logger.warn(`[attachments] ${m}`),
+  );
+
+  // Public http(s) images/videos: let the provider fetch the URL itself.
+  const isHttpUrl =
+    Boolean(attachment.mxcUri) &&
+    !attachment.eventId &&
+    /^https?:\/\//i.test(attachment.mxcUri ?? '');
+  let text: string | undefined;
+  let usage: ExtractionUsage | undefined;
+  if (
+    isHttpUrl &&
+    deps.extraction &&
+    (category === 'image' || category === 'video')
+  ) {
+    try {
+      const passthrough = await aiProcessFromUrl(
+        attachment.mxcUri!,
+        category,
+        deps.extraction,
+        { fetchImpl: deps.fetchImpl, signal: deps.signal },
+      );
+      if (passthrough.content.trim().length > 0) {
+        text = formatContent('Description', safeName, passthrough.content);
+        usage = passthrough.usage;
+      }
+    } catch (error) {
+      deps.logger.warn(
+        `[attachments] URL passthrough failed for "${attachment.filename}", falling back to bytes: ${errorMessage(error)}`,
+      );
+    }
+  }
+  if (text === undefined) {
+    const extracted = await extractText(
+      bytes,
+      attachment,
+      category,
+      deps.extraction,
+      { fetchImpl: deps.fetchImpl, signal: deps.signal },
+    );
+    text = extracted.text;
+    usage = extracted.usage;
+  }
+
+  if (!deps.sandbox) {
+    return { text, downloaded: bytes.length, ...(usage ? { usage } : {}) };
+  }
+  const destPath = `${SANDBOX_OUTPUT_PREFIX}/${safeName}`;
+  try {
+    await uploadToSandbox(
+      bytes,
+      safeName,
+      destPath,
+      deps.sandbox,
+      attachment.mimetype,
+      deps.fetchImpl,
+    );
+    const actualPath = sanitizeSandboxPath(destPath);
+    let analysisPath: string | undefined;
+    if (category === 'image' || category === 'video' || category === 'audio') {
+      const analysisFilename = `${safeName.replace(/\.[^.]+$/, '')}-analysis.md`;
+      const analysisDest = `${SANDBOX_OUTPUT_PREFIX}/${analysisFilename}`;
+      try {
+        await uploadToSandbox(
+          new TextEncoder().encode(
+            buildAnalysisMarkdown(
+              safeName,
+              attachment.mimetype,
+              bytes.length,
+              category,
+              text,
+            ),
+          ),
+          analysisFilename,
+          analysisDest,
+          deps.sandbox,
+          'text/markdown',
+          deps.fetchImpl,
+        );
+        analysisPath = sanitizeSandboxPath(analysisDest);
+      } catch (error) {
+        deps.logger.warn(
+          `[attachments] analysis .md upload failed for "${attachment.filename}": ${errorMessage(error)}`,
+        );
+      }
+    }
+    if (text.length > SANDBOX_TRUNCATE_LIMIT) {
+      const paths = analysisPath
+        ? `\n\n[Full analysis saved to sandbox at ${analysisPath}]\n[Original file saved to sandbox at ${actualPath}]`
+        : `\n\n[Full file saved to sandbox at ${actualPath}]`;
+      return {
+        text: text.slice(0, SANDBOX_TRUNCATE_LIMIT) + paths,
+        downloaded: bytes.length,
+        ...(usage ? { usage } : {}),
+      };
+    }
+    const suffix = analysisPath
+      ? `\n\n[Analysis saved to sandbox at ${analysisPath}]\n[File also saved to sandbox at ${actualPath}]`
+      : `\n\n[File also saved to sandbox at ${actualPath}]`;
+    return {
+      text: text + suffix,
+      downloaded: bytes.length,
+      ...(usage ? { usage } : {}),
+    };
+  } catch (error) {
+    deps.logger.warn(
+      `[attachments] sandbox upload failed for "${attachment.filename}": ${errorMessage(error)}`,
+    );
+    return {
+      text: `${text}\n\n[Warning: sandbox upload failed — file content is included above]`,
+      downloaded: bytes.length,
+      ...(usage ? { usage } : {}),
+    };
+  }
+}
+
+export async function prepareAttachments(
+  params: PrepareAttachmentsParams,
+  deps: AttachmentPipelineDeps,
+): Promise<PreparedAttachments> {
+  const metas = params.attachments.map(metaFor);
+  const usage = { cost: 0, promptTokens: 0, completionTokens: 0 };
+  if (params.attachments.length === 0) {
+    return { content: params.text, metas, extracted: [], usage };
+  }
+
+  const reportedTotal = params.attachments.reduce(
+    (sum, a) => sum + (a.size ?? 0),
+    0,
+  );
+  if (reportedTotal > MAX_TOTAL_SIZE) {
+    throw new Error(
+      `Total attachment size (${Math.round(reportedTotal / 1024 / 1024)} MB) exceeds budget (${Math.round(MAX_TOTAL_SIZE / 1024 / 1024)} MB)`,
+    );
+  }
+
+  const nativeCandidates: AttachmentInput[] = [];
+  const extractQueue: AttachmentInput[] = [];
+  for (const attachment of params.attachments) {
+    const kind = classifyAttachment(attachment);
+    const strategy = routeAttachment(kind, params.caps);
+    deps.logger.log(
+      `[attachments] "${attachment.filename}" (${attachment.mimetype}) kind=${kind} model=${params.model} → ${strategy}`,
+    );
+    if (strategy === 'send-native') nativeCandidates.push(attachment);
+    else extractQueue.push(attachment);
+  }
+
+  const natives: NativeAttachment[] = [];
+  let nativeBytesTotal = 0;
+  for (const attachment of nativeCandidates) {
+    try {
+      const { bytes, mimetype } = await loadAttachmentBytes(
+        attachment,
+        params.roomId,
+        deps.source,
+        { fetchImpl: deps.fetchImpl, signal: deps.signal },
+      );
+      if (nativeBytesTotal + bytes.length > MAX_TOTAL_SIZE) {
+        deps.logger.warn(
+          `[attachments] native budget (${Math.round(MAX_TOTAL_SIZE / 1024 / 1024)} MB) exceeded at "${attachment.filename}" — falling back to extraction`,
+        );
+        extractQueue.push(attachment);
+        continue;
+      }
+      nativeBytesTotal += bytes.length;
+      const kind = classifyAttachment({
+        mimetype,
+        filename: attachment.filename,
+      });
+      natives.push({
+        kind: kind === 'image' ? 'image' : 'file',
+        mimeType: mimetype,
+        base64: bytesToBase64(bytes),
+        filename: attachment.filename,
+      });
+      deps.logger.log(
+        `[attachments] NATIVE → "${attachment.filename}" sent directly to ${params.model} (${bytes.length} bytes, ${kind})`,
+      );
+      if (deps.sandbox) {
+        const safeName = sanitizeAttachmentFilename(attachment.filename);
+        // Off the hot path — the agent's file tools can reach the original later.
+        void uploadToSandbox(
+          bytes,
+          safeName,
+          `${SANDBOX_OUTPUT_PREFIX}/${safeName}`,
+          deps.sandbox,
+          mimetype,
+          deps.fetchImpl,
+        ).catch((error: unknown) => {
+          deps.logger.warn(
+            `[attachments] background archive failed for "${attachment.filename}": ${errorMessage(error)}`,
+          );
+        });
+      }
+    } catch (error) {
+      deps.logger.warn(
+        `[attachments] native load failed for "${attachment.filename}", falling back to extraction: ${errorMessage(error)}`,
+      );
+      extractQueue.push(attachment);
+    }
+  }
+
+  const extracted: ExtractedAttachment[] = [];
+  if (extractQueue.length > 0) {
+    deps.logger.log(
+      `[attachments] EXTRACT ${extractQueue.length} attachment(s) (local parse for text, helper model otherwise)`,
+    );
+    if (!deps.sandbox) {
+      deps.logger.warn(
+        '[attachments] sandbox archive unavailable for this turn — originals are not archived',
+      );
+    }
+    let downloadedTotal = 0;
+    for (const attachment of extractQueue) {
+      const meta = metaFor(attachment);
+      let text: string;
+      try {
+        const result = await extractOne(
+          attachment,
+          downloadedTotal,
+          params,
+          deps,
+        );
+        downloadedTotal += result.downloaded;
+        if (downloadedTotal > MAX_TOTAL_SIZE) {
+          throw new Error(
+            `Total downloaded size (${Math.round(downloadedTotal / 1024 / 1024)} MB) exceeds budget (${Math.round(MAX_TOTAL_SIZE / 1024 / 1024)} MB)`,
+          );
+        }
+        if (result.usage) {
+          usage.cost += result.usage.cost ?? 0;
+          usage.promptTokens += result.usage.promptTokens ?? 0;
+          usage.completionTokens += result.usage.completionTokens ?? 0;
+        }
+        text = result.text;
+      } catch (error) {
+        deps.logger.error(
+          `[attachments] failed to process ${attachment.filename}: ${errorMessage(error)}`,
+        );
+        text = `[File "${sanitizeAttachmentFilename(attachment.filename)}" (${attachment.mimetype}) failed to process: ${errorMessage(error)}]`;
+      }
+      const ref = sourceRef(attachment);
+      extracted.push({ text: ref ? `${ref}\n${text}` : text, meta });
+    }
+  }
+
+  return {
+    content: buildUserMessageContent(params.text, natives),
+    metas,
+    extracted,
+    usage,
+  };
+}

package/src/attachments/retention.ts

@@ -0,0 +1,205 @@
+/**
+ * Attachment payload retention.
+ *
+ * A human turn whose attachments the model reads natively stores the bytes
+ * inline, as base64 content blocks, in the persisted message. On Workers that
+ * payload is replayed to the model on every later turn of the session and
+ * sits in the per-user SQLite (and its VFS copy) for good, so once a turn is
+ * older than the newest `ATTACHMENT_PAYLOAD_TURNS` user turns its inline
+ * blocks are replaced by one compact text placeholder. The placeholder lists
+ * the message's attachments with the reference `view_attachment` takes, and
+ * the metadata the Portal renders from (`additional_kwargs.attachment(s)`)
+ * is left untouched, so transcripts do not change.
+ *
+ * The rewrite is a pure function of the thread's messages and idempotent: a
+ * rewritten message has no inline block left, so it is never selected again.
+ */
+import { HumanMessage, type BaseMessage } from '@langchain/core/messages';
+import type { AttachmentMeta } from '../sqlite/serialization';
+
+/** Newest user turns whose inline attachment payloads stay in the messages. */
+export const ATTACHMENT_PAYLOAD_TURNS = 2;
+
+/**
+ * `additional_kwargs.lc_source` of the human message `view_attachment` adds
+ * to re-attach a payload — hidden from transcripts and not a user turn.
+ */
+export const ATTACHMENT_VIEW_SOURCE = 'attachment_view';
+
+/** Every placeholder text block starts with this (transcripts drop it). */
+export const ATTACHMENT_PLACEHOLDER_PREFIX = '[attachment offloaded]';
+
+/**
+ * Substring every inline payload block serialises to (`message_content`
+ * holds the JSON of an array content), for a SQL `LIKE` pre-filter that
+ * finds candidate rows without inflating message blobs.
+ */
+export const INLINE_PAYLOAD_NEEDLE = '"source_type":"base64"';
+
+export const VIEW_ATTACHMENT_TOOL_NAME = 'view_attachment';
+
+interface InlinePayloadBlock {
+  type: string;
+  source_type: 'base64';
+  data: string;
+  mime_type?: string;
+  filename?: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function isAttachmentMeta(value: unknown): value is AttachmentMeta {
+  return (
+    isRecord(value) &&
+    typeof value.filename === 'string' &&
+    typeof value.mimetype === 'string' &&
+    typeof value.category === 'string'
+  );
+}
+
+/** A LangChain data content block carrying base64 bytes (`image` / `file`). */
+export function isInlinePayloadBlock(
+  block: unknown,
+): block is InlinePayloadBlock {
+  return (
+    isRecord(block) &&
+    typeof block.type === 'string' &&
+    block.source_type === 'base64' &&
+    typeof block.data === 'string'
+  );
+}
+
+export function hasInlinePayload(message: BaseMessage): boolean {
+  return (
+    Array.isArray(message.content) &&
+    message.content.some((block) => isInlinePayloadBlock(block))
+  );
+}
+
+export function isAttachmentPlaceholderText(text: string): boolean {
+  return text.startsWith(ATTACHMENT_PLACEHOLDER_PREFIX);
+}
+
+/** The re-attachment message `view_attachment` injects (not a user turn). */
+export function isAttachmentViewMessage(message: BaseMessage): boolean {
+  return (
+    message.type === 'human' &&
+    message.additional_kwargs?.lc_source === ATTACHMENT_VIEW_SOURCE
+  );
+}
+
+/** The reference `view_attachment` takes: the media event id, else the URI. */
+export function attachmentRef(meta: AttachmentMeta): string | undefined {
+  return meta.eventId ?? meta.mxcUri;
+}
+
+/** The attachment metadata a message carries (`attachments`, else `attachment`). */
+export function attachmentMetas(message: BaseMessage): AttachmentMeta[] {
+  const kw = message.additional_kwargs ?? {};
+  if (Array.isArray(kw.attachments)) {
+    return kw.attachments.filter(isAttachmentMeta);
+  }
+  return isAttachmentMeta(kw.attachment) ? [kw.attachment] : [];
+}
+
+function formatSize(size: number | undefined): string {
+  if (size === undefined) return '';
+  if (size < 1024) return `, ${size} B`;
+  if (size < 1024 * 1024) return `, ${Math.round(size / 1024)} KB`;
+  return `, ${(size / 1024 / 1024).toFixed(1)} MB`;
+}
+
+/** The text block that replaces a message's inline payload blocks. */
+export function buildPlaceholderText(metas: AttachmentMeta[]): string {
+  const lines = metas.map((meta, i) => {
+    const ref = attachmentRef(meta);
+    return `${i + 1}. "${meta.filename}" (${meta.mimetype}${formatSize(meta.size)})${
+      ref ? ` — ref: ${ref}` : ' — no reference; it cannot be fetched again'
+    }`;
+  });
+  const listing =
+    lines.length > 0
+      ? `Attachments of this message:\n${lines.join('\n')}\n`
+      : 'This message had an attachment whose metadata was not recorded; it cannot be fetched again.\n';
+  return (
+    `${ATTACHMENT_PLACEHOLDER_PREFIX} The attachment bytes of this message are no longer inline ` +
+    `(only the newest ${ATTACHMENT_PAYLOAD_TURNS} user turns keep them). ${listing}` +
+    `To look at one again, call ${VIEW_ATTACHMENT_TOOL_NAME} with its ref.`
+  );
+}
+
+/**
+ * A copy of `message` with every inline payload block replaced by one
+ * placeholder text block (id, kwargs and response metadata preserved), or
+ * null when the message carries no inline payload.
+ */
+export function offloadInlinePayloads(
+  message: BaseMessage,
+): BaseMessage | null {
+  if (!Array.isArray(message.content)) return null;
+  if (!message.content.some((block) => isInlinePayloadBlock(block)))
+    return null;
+  const placeholder = {
+    type: 'text',
+    text: buildPlaceholderText(attachmentMetas(message)),
+  };
+  let placed = false;
+  const content: typeof message.content = [];
+  for (const block of message.content) {
+    if (!isInlinePayloadBlock(block)) {
+      content.push(block);
+      continue;
+    }
+    if (!placed) {
+      content.push(placeholder);
+      placed = true;
+    }
+  }
+  return new HumanMessage({
+    id: message.id,
+    content,
+    additional_kwargs: message.additional_kwargs,
+    response_metadata: message.response_metadata,
+  });
+}
+
+export interface AttachmentRetentionResult {
+  /** Ids of the messages whose inline payload stays (inside the window). */
+  retainedIds: Set<string>;
+  /** Rewritten copies of the messages that fell out of the window. */
+  rewrites: BaseMessage[];
+}
+
+/**
+ * Decide, for the thread's current messages (oldest first), which inline
+ * payloads stay and which get a placeholder. A payload belongs to the user
+ * turn it was posted in — a re-attachment message belongs to the turn of the
+ * user message before it — and stays while that turn is one of the newest
+ * `keepTurns` user turns. Messages without an id cannot be rewritten in
+ * place and are left alone.
+ */
+export function applyAttachmentRetention(
+  messages: readonly BaseMessage[],
+  keepTurns: number = ATTACHMENT_PAYLOAD_TURNS,
+): AttachmentRetentionResult {
+  const retainedIds = new Set<string>();
+  const rewrites: BaseMessage[] = [];
+  let turnsSeen = 0;
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i]!;
+    if (message.type !== 'human') continue;
+    const userTurn = !isAttachmentViewMessage(message);
+    if (userTurn) turnsSeen += 1;
+    if (!hasInlinePayload(message) || !message.id) continue;
+    const turnIndex = userTurn ? turnsSeen : turnsSeen + 1;
+    if (turnIndex <= keepTurns) {
+      retainedIds.add(message.id);
+      continue;
+    }
+    const rewritten = offloadInlinePayloads(message);
+    if (rewritten) rewrites.push(rewritten);
+  }
+  return { retainedIds, rewrites };
+}

package/src/attachments/route.ts

@@ -0,0 +1,41 @@
+import type { ModelInputCapabilities } from '../core/llm';
+import type { AttachmentKind } from './classify';
+
+/**
+ * How an attachment reaches the model (verbatim port of the Node rule):
+ * - `parse-local`   — read to text ourselves (free). Plain-text files only.
+ * - `send-native`   — attach the raw bytes to the user message; the selected
+ *                     model reads it directly. Only when the model accepts that
+ *                     modality.
+ * - `model-extract` — the helper (vision) model turns it into text first. Used
+ *                     for anything the selected model can't accept natively.
+ */
+export type AttachmentStrategy =
+  | 'parse-local'
+  | 'send-native'
+  | 'model-extract';
+
+/**
+ * Decide, for one attachment, how to get it to the selected model — the single
+ * cost-aware, capability-aware routing rule. Pure and total.
+ */
+export function routeAttachment(
+  kind: AttachmentKind,
+  caps: ModelInputCapabilities,
+): AttachmentStrategy {
+  switch (kind) {
+    case 'text':
+      return 'parse-local';
+    case 'image':
+      return caps.image ? 'send-native' : 'model-extract';
+    case 'document':
+      return caps.file ? 'send-native' : 'model-extract';
+    case 'audio':
+      return caps.audio ? 'send-native' : 'model-extract';
+    case 'video':
+      return caps.video ? 'send-native' : 'model-extract';
+    case 'unknown':
+    default:
+      return 'model-extract';
+  }
+}