@hybridaione/hybridclaw 0.2.1 → 0.2.2

package/src/{discord-stream.ts → channels/discord/stream.ts}

@@ -3,8 +3,8 @@ import {
   type Message as DiscordMessage,
 } from 'discord.js';
 
-import { chunkMessage } from './chunk.js';
-import { logger } from './logger.js';
+import { chunkMessage } from '../../chunk.js';
+import { logger } from '../../logger.js';
 
 interface DiscordSendChannel {
   send: (payload: { content: string; files?: AttachmentBuilder[] }) => Promise<DiscordMessage>;

package/src/channels/discord/tool-actions.ts

@@ -0,0 +1,332 @@
+import type { Client, GuildMember } from 'discord.js';
+
+export type DiscordToolAction = 'read' | 'member-info' | 'channel-info';
+
+export interface DiscordToolActionRequest {
+  action: DiscordToolAction;
+  channelId?: string;
+  guildId?: string;
+  userId?: string;
+  username?: string;
+  user?: string;
+  memberId?: string;
+  limit?: number;
+  before?: string;
+  after?: string;
+  around?: string;
+}
+
+export interface CachedDiscordPresenceActivity {
+  type: number;
+  name: string;
+  state: string | null;
+  details: string | null;
+}
+
+export interface CachedDiscordPresence {
+  status: string;
+  activities: CachedDiscordPresenceActivity[];
+}
+
+export interface DiscordToolActionDependencies {
+  requireDiscordClientReady: () => Client;
+  getDiscordPresence: (userId: string) => CachedDiscordPresence | undefined;
+}
+
+function sanitizeDiscordId(rawValue: string | undefined, label: string): string {
+  const value = (rawValue || '').trim();
+  if (!/^\d{16,22}$/.test(value)) {
+    throw new Error(`${label} must be a Discord snowflake id.`);
+  }
+  return value;
+}
+
+function normalizeDiscordUserLookupQuery(rawValue: string | undefined): string {
+  const trimmed = (rawValue || '').trim();
+  if (!trimmed) return '';
+
+  const mentionMatch = trimmed.match(/^<@!?(\d{16,22})>$/);
+  if (mentionMatch) return mentionMatch[1];
+  const prefixedId = trimmed.match(/^(?:user:|discord:)?(\d{16,22})$/i);
+  if (prefixedId) return prefixedId[1];
+
+  return trimmed.replace(/^@+/, '').trim();
+}
+
+function scoreGuildMemberForLookup(member: GuildMember, query: string): number {
+  const q = query.toLowerCase();
+  const username = member.user.username?.toLowerCase() || '';
+  const globalName = member.user.globalName?.toLowerCase() || '';
+  const nickname = member.nickname?.toLowerCase() || '';
+  const displayName = member.displayName?.toLowerCase() || '';
+  const candidates = [username, globalName, nickname, displayName].filter(Boolean);
+
+  let score = 0;
+  if (candidates.some((value) => value === q)) score += 3;
+  if (candidates.some((value) => value.includes(q))) score += 1;
+  if (!member.user.bot) score += 1;
+  return score;
+}
+
+async function resolveGuildMemberIdFromLookup(params: {
+  requireDiscordClientReady: () => Client;
+  guildId: string;
+  rawUser: string;
+}): Promise<{ userId: string; note?: string }> {
+  const activeClient = params.requireDiscordClientReady();
+  const guildId = sanitizeDiscordId(params.guildId, 'guildId');
+  const normalized = normalizeDiscordUserLookupQuery(params.rawUser);
+  if (!normalized) {
+    throw new Error('userId or username is required.');
+  }
+  if (/^\d{16,22}$/.test(normalized)) {
+    return { userId: normalized };
+  }
+
+  const guild = await activeClient.guilds.fetch(guildId);
+  const searchQuery = normalized.slice(0, 32);
+  if (!searchQuery) {
+    throw new Error('username query is empty after normalization.');
+  }
+
+  let members: Map<string, GuildMember>;
+  try {
+    members = await guild.members.search({ query: searchQuery, limit: 25 });
+  } catch {
+    const fetched = await guild.members.fetch({ query: searchQuery, limit: 25 });
+    members = fetched;
+  }
+  let best: GuildMember | null = null;
+  let bestScore = 0;
+  let matchCount = 0;
+  for (const member of members.values()) {
+    const score = scoreGuildMemberForLookup(member, searchQuery);
+    if (score <= 0) continue;
+    matchCount += 1;
+    if (!best || score > bestScore) {
+      best = member;
+      bestScore = score;
+    }
+  }
+
+  if (!best) {
+    throw new Error(`No guild member matched username "${searchQuery}".`);
+  }
+
+  return {
+    userId: best.id,
+    note: matchCount > 1 ? 'multiple matches; chose best' : undefined,
+  };
+}
+
+function normalizeDate(value: Date | null | undefined): string | null {
+  if (!value) return null;
+  const ms = value.getTime();
+  if (!Number.isFinite(ms)) return null;
+  return value.toISOString();
+}
+
+async function runDiscordReadAction(
+  request: DiscordToolActionRequest,
+  deps: DiscordToolActionDependencies,
+): Promise<Record<string, unknown>> {
+  const activeClient = deps.requireDiscordClientReady();
+  const channelId = sanitizeDiscordId(request.channelId, 'channelId');
+  const channel = await activeClient.channels.fetch(channelId);
+  if (!channel || !('messages' in channel)) {
+    throw new Error('Channel does not support message reads.');
+  }
+
+  const requestedLimit =
+    typeof request.limit === 'number' && Number.isFinite(request.limit)
+      ? Math.floor(request.limit)
+      : 20;
+  const limit = Math.max(1, Math.min(100, requestedLimit));
+  const before = request.before?.trim();
+  const after = request.after?.trim();
+  const around = request.around?.trim();
+
+  const query: { limit: number; before?: string; after?: string; around?: string } = { limit };
+  if (before) query.before = before;
+  if (after) query.after = after;
+  if (around) query.around = around;
+
+  const fetched = await channel.messages.fetch(query);
+  const messages = Array.from(fetched.values())
+    .sort((a, b) => a.createdTimestamp - b.createdTimestamp || a.id.localeCompare(b.id))
+    .map((message) => ({
+      id: message.id,
+      channelId: message.channelId,
+      guildId: message.guildId ?? null,
+      content: message.content || '',
+      createdAt: new Date(message.createdTimestamp).toISOString(),
+      editedAt: normalizeDate(message.editedAt),
+      author: {
+        id: message.author?.id || 'unknown',
+        username: message.author?.username || 'unknown',
+        handle: message.author?.username ? `@${message.author.username}` : null,
+        globalName: message.author?.globalName || null,
+        bot: Boolean(message.author?.bot),
+      },
+      member: message.member
+        ? {
+            id: message.member.id,
+            nickname: message.member.nickname || null,
+            displayName: message.member.displayName || null,
+          }
+        : null,
+      attachments: Array.from(message.attachments.values()).map((attachment) => ({
+        id: attachment.id,
+        name: attachment.name || null,
+        url: attachment.url,
+        contentType: attachment.contentType || null,
+        size: attachment.size,
+      })),
+      mentions: {
+        users: Array.from(message.mentions.users.values()).map((user) => ({
+          id: user.id,
+          username: user.username,
+          bot: Boolean(user.bot),
+        })),
+        roles: Array.from(message.mentions.roles.values()).map((role) => ({
+          id: role.id,
+          name: role.name,
+        })),
+        channels: Array.from(message.mentions.channels.values()).map((mentionedChannel) => ({
+          id: mentionedChannel.id,
+          name: 'name' in mentionedChannel && typeof mentionedChannel.name === 'string'
+            ? mentionedChannel.name
+            : null,
+        })),
+      },
+    }));
+
+  return {
+    ok: true,
+    action: 'read',
+    channelId,
+    count: messages.length,
+    messages,
+  };
+}
+
+async function runDiscordMemberInfoAction(
+  request: DiscordToolActionRequest,
+  deps: DiscordToolActionDependencies,
+): Promise<Record<string, unknown>> {
+  const activeClient = deps.requireDiscordClientReady();
+  const guildId = sanitizeDiscordId(request.guildId, 'guildId');
+  const userLookupRaw =
+    request.userId
+    || request.memberId
+    || request.user
+    || request.username;
+  const resolvedUser = await resolveGuildMemberIdFromLookup({
+    requireDiscordClientReady: deps.requireDiscordClientReady,
+    guildId,
+    rawUser: userLookupRaw || '',
+  });
+  const userId = sanitizeDiscordId(resolvedUser.userId, 'userId');
+
+  const guild = await activeClient.guilds.fetch(guildId);
+  const member = await guild.members.fetch(userId);
+  const presence = deps.getDiscordPresence(userId);
+
+  const roles = member.roles.cache
+    .filter((role) => role.id !== guild.id)
+    .map((role) => ({
+      id: role.id,
+      name: role.name,
+      color: role.hexColor,
+      position: role.position,
+    }))
+    .sort((a, b) => b.position - a.position || a.name.localeCompare(b.name));
+
+  return {
+    ok: true,
+    action: 'member-info',
+    guildId,
+    userId,
+    ...(resolvedUser.note ? { note: resolvedUser.note } : {}),
+    member: {
+      id: member.id,
+      username: member.user.username,
+      handle: member.user.username ? `@${member.user.username}` : null,
+      globalName: member.user.globalName || null,
+      bot: Boolean(member.user.bot),
+      displayName: member.displayName,
+      nickname: member.nickname || null,
+      joinedAt: normalizeDate(member.joinedAt),
+      premiumSince: normalizeDate(member.premiumSince),
+      communicationDisabledUntil: normalizeDate(member.communicationDisabledUntil),
+      roles,
+    },
+    ...(presence
+      ? {
+          status: presence.status,
+          activities: presence.activities,
+        }
+      : {}),
+  };
+}
+
+async function runDiscordChannelInfoAction(
+  request: DiscordToolActionRequest,
+  deps: DiscordToolActionDependencies,
+): Promise<Record<string, unknown>> {
+  const activeClient = deps.requireDiscordClientReady();
+  const channelId = sanitizeDiscordId(request.channelId, 'channelId');
+  const channel = await activeClient.channels.fetch(channelId);
+  if (!channel) {
+    throw new Error('Channel not found.');
+  }
+
+  const channelData: Record<string, unknown> = {
+    id: channel.id,
+    type: channel.type,
+    guildId: 'guildId' in channel ? channel.guildId || null : null,
+    name: 'name' in channel && typeof channel.name === 'string' ? channel.name : null,
+    parentId: 'parentId' in channel ? channel.parentId || null : null,
+    topic: 'topic' in channel && typeof channel.topic === 'string' ? channel.topic : null,
+    nsfw: 'nsfw' in channel && typeof channel.nsfw === 'boolean' ? channel.nsfw : null,
+    rateLimitPerUser:
+      'rateLimitPerUser' in channel && typeof channel.rateLimitPerUser === 'number'
+        ? channel.rateLimitPerUser
+        : null,
+    isTextBased: typeof channel.isTextBased === 'function' ? channel.isTextBased() : false,
+    isDMBased: typeof channel.isDMBased === 'function' ? channel.isDMBased() : false,
+    isThread: typeof channel.isThread === 'function' ? channel.isThread() : false,
+    lastMessageId: 'lastMessageId' in channel ? channel.lastMessageId || null : null,
+  };
+
+  if (typeof channel.isThread === 'function' && channel.isThread()) {
+    channelData.archived =
+      'archived' in channel && typeof channel.archived === 'boolean' ? channel.archived : null;
+    channelData.locked =
+      'locked' in channel && typeof channel.locked === 'boolean' ? channel.locked : null;
+    channelData.ownerId = 'ownerId' in channel ? channel.ownerId || null : null;
+  }
+
+  return {
+    ok: true,
+    action: 'channel-info',
+    channel: channelData,
+  };
+}
+
+export function createDiscordToolActionRunner(deps: DiscordToolActionDependencies): (
+  request: DiscordToolActionRequest,
+) => Promise<Record<string, unknown>> {
+  return async (request: DiscordToolActionRequest) => {
+    switch (request.action) {
+      case 'read':
+        return await runDiscordReadAction(request, deps);
+      case 'member-info':
+        return await runDiscordMemberInfoAction(request, deps);
+      case 'channel-info':
+        return await runDiscordChannelInfoAction(request, deps);
+      default:
+        throw new Error(`Unsupported Discord action: ${request.action as string}`);
+    }
+  };
+}

package/src/container-runner.ts

@@ -3,6 +3,7 @@
  * Containers stay alive between requests and exit after an idle timeout.
  */
 import { ChildProcess, spawn } from 'child_process';
+import fs from 'fs';
 import path from 'path';
 
 import {
@@ -11,6 +12,7 @@ import {
   CONTAINER_IMAGE,
   CONTAINER_MEMORY,
   CONTAINER_TIMEOUT,
+  DATA_DIR,
   GATEWAY_API_TOKEN,
   GATEWAY_BASE_URL,
   HYBRIDAI_BASE_URL,
@@ -26,7 +28,16 @@ import {
 import { cleanupIpc, ensureAgentDirs, ensureSessionDirs, getSessionPaths, readOutput, writeInput } from './ipc.js';
 import { logger } from './logger.js';
 import { validateAdditionalMounts } from './mount-security.js';
-import type { AdditionalMount, ArtifactMetadata, ChatMessage, ContainerInput, ContainerOutput, ScheduledTask, ToolProgressEvent } from './types.js';
+import type {
+  AdditionalMount,
+  ArtifactMetadata,
+  ChatMessage,
+  ContainerInput,
+  ContainerOutput,
+  MediaContextItem,
+  ScheduledTask,
+  ToolProgressEvent,
+} from './types.js';
 
 const IDLE_TIMEOUT_MS = 300_000; // 5 minutes — matches container-side default
 
@@ -45,6 +56,11 @@ const TOOL_RESULT_RE = /^\[tool\]\s+([a-zA-Z0-9_.-]+)\s+result\s+\((\d+)ms\):\s*
 const TOOL_START_RE = /^\[tool\]\s+([a-zA-Z0-9_.-]+):\s*(.*)$/;
 const STREAM_DELTA_RE = /^\[stream\]\s+([A-Za-z0-9+/=]+)$/;
 const CONTAINER_WORKSPACE_ROOT = '/workspace';
+const CONTAINER_DISCORD_MEDIA_CACHE_ROOT = '/discord-media-cache';
+
+function resolveDiscordMediaCacheHostDir(): string {
+  return path.resolve(path.join(DATA_DIR, 'discord-media-cache'));
+}
 
 function emitTextDelta(entry: PoolEntry, line: string): void {
   const callback = entry.onTextDelta;
@@ -184,6 +200,8 @@ function getOrSpawnContainer(sessionId: string, agentId: string): PoolEntry {
   ensureSessionDirs(sessionId);
   ensureAgentDirs(agentId);
   const { ipcPath, workspacePath } = getSessionPaths(sessionId, agentId);
+  const mediaCacheHostPath = resolveDiscordMediaCacheHostDir();
+  fs.mkdirSync(mediaCacheHostPath, { recursive: true });
   const containerName = `hybridclaw-${sessionId.replace(/[^a-zA-Z0-9-]/g, '-')}-${Date.now()}`;
 
   const args = [
@@ -197,6 +215,7 @@ function getOrSpawnContainer(sessionId: string, agentId: string): PoolEntry {
     '--tmpfs', '/tmp',
     '-v', `${workspacePath}:/workspace:rw`,
     '-v', `${ipcPath}:/ipc:rw`,
+    '-v', `${mediaCacheHostPath}:${CONTAINER_DISCORD_MEDIA_CACHE_ROOT}:ro`,
     '-e', `HYBRIDAI_BASE_URL=${HYBRIDAI_BASE_URL}`,
     '-e', `HYBRIDAI_MODEL=${HYBRIDAI_MODEL}`,
     '-e', `CONTAINER_IDLE_TIMEOUT=${IDLE_TIMEOUT_MS}`,
@@ -292,9 +311,11 @@ export async function runContainer(
   channelId: string = '',
   scheduledTasks?: ScheduledTask[],
   allowedTools?: string[],
+  blockedTools?: string[],
   onTextDelta?: (delta: string) => void,
   onToolProgress?: (event: ToolProgressEvent) => void,
   abortSignal?: AbortSignal,
+  media?: MediaContextItem[],
 ): Promise<ContainerOutput> {
   const { workspacePath } = getSessionPaths(sessionId, agentId);
   // Enforce concurrent container limit
@@ -349,6 +370,8 @@ export async function runContainer(
       createdAt: t.created_at,
     })),
     allowedTools,
+    blockedTools,
+    media,
   };
 
   entry.onTextDelta = onTextDelta;

package/src/gateway-service.ts

@@ -59,6 +59,7 @@ import type {
   ChatMessage,
   DelegationSideEffect,
   DelegationTaskSpec,
+  MediaContextItem,
   ScheduledTask,
   StructuredAuditEntry,
   StoredMessage,
@@ -95,6 +96,8 @@ const BASE_SUBAGENT_ALLOWED_TOOLS = [
   'browser_screenshot',
   'browser_pdf',
   'browser_vision',
+  'vision_analyze',
+  'image',
   'browser_get_images',
   'browser_console',
   'browser_network',
@@ -104,6 +107,10 @@ const ORCHESTRATOR_SUBAGENT_ALLOWED_TOOLS = [...BASE_SUBAGENT_ALLOWED_TOOLS, 'de
 const MAX_DELEGATION_TASKS = 6;
 const MAX_DELEGATION_USER_CHARS = 500;
 const MAX_RALPH_ITERATIONS = 64;
+const IMAGE_QUESTION_RE =
+  /(what(?:'s| is)? on (?:the )?(?:image|picture|photo|screenshot)|describe (?:this|the) (?:image|picture|photo)|image|picture|photo|screenshot|ocr|diagram|chart|grafik|bild|foto|was steht|was ist auf dem bild)/i;
+const BROWSER_TAB_RE =
+  /(browser|tab|current tab|web page|website|seite im browser|aktuellen tab)/i;
 const TRANSIENT_DELEGATION_ERROR_PATTERNS: RegExp[] = [
   /econnreset/i,
   /etimedout/i,
@@ -177,6 +184,7 @@ export interface GatewayChatRequest {
   userId: GatewayChatRequestBody['userId'];
   username: GatewayChatRequestBody['username'];
   content: GatewayChatRequestBody['content'];
+  media?: GatewayChatRequestBody['media'];
   chatbotId?: GatewayChatRequestBody['chatbotId'];
   model?: GatewayChatRequestBody['model'];
   enableRag?: GatewayChatRequestBody['enableRag'];
@@ -213,6 +221,102 @@ function parseIntOrNull(raw: string | undefined): number | null {
   return Number.isNaN(parsed) ? null : parsed;
 }
 
+function normalizeMediaContextItems(raw: GatewayChatRequestBody['media']): MediaContextItem[] {
+  if (!Array.isArray(raw) || raw.length === 0) return [];
+  const normalized: MediaContextItem[] = [];
+  for (const item of raw) {
+    if (!item || typeof item !== 'object') continue;
+    const path = typeof item.path === 'string' && item.path.trim() ? item.path.trim() : null;
+    const url = typeof item.url === 'string' ? item.url.trim() : '';
+    const originalUrl = typeof item.originalUrl === 'string' ? item.originalUrl.trim() : '';
+    const filename = typeof item.filename === 'string' ? item.filename.trim() : '';
+    if (!url || !originalUrl || !filename) continue;
+    const sizeBytes = typeof item.sizeBytes === 'number' && Number.isFinite(item.sizeBytes)
+      ? Math.max(0, Math.floor(item.sizeBytes))
+      : 0;
+    const mimeType = typeof item.mimeType === 'string' && item.mimeType.trim()
+      ? item.mimeType.trim().toLowerCase()
+      : null;
+    normalized.push({
+      path,
+      url,
+      originalUrl,
+      mimeType,
+      sizeBytes,
+      filename,
+    });
+  }
+  return normalized;
+}
+
+function buildMediaPromptContext(media: MediaContextItem[]): string {
+  if (media.length === 0) return '';
+  const mediaPaths = media.map((item) => item.path).filter((path): path is string => Boolean(path));
+  const mediaUrls = media.map((item) => item.url);
+  const mediaTypes = media.map((item) => item.mimeType || 'unknown');
+  const payload = media.map((item, index) => ({
+    order: index + 1,
+    path: item.path,
+    mime: item.mimeType || 'unknown',
+    size: item.sizeBytes,
+    filename: item.filename,
+    original_url: item.originalUrl,
+    url: item.url,
+  }));
+  return [
+    '[MediaContext]',
+    `MediaPaths: ${JSON.stringify(mediaPaths)}`,
+    `MediaUrls: ${JSON.stringify(mediaUrls)}`,
+    `MediaTypes: ${JSON.stringify(mediaTypes)}`,
+    `MediaItems: ${JSON.stringify(payload)}`,
+    'When the user asks about these Discord files, use `vision_analyze` with `image_url` from MediaPaths first.',
+    'Use MediaUrls as fallback when a local path is missing or fails to open.',
+    'Use `browser_vision` only for questions about the active browser tab/page.',
+    '',
+    '',
+  ].join('\n');
+}
+
+function isImageQuestion(content: string): boolean {
+  const normalized = content.trim();
+  if (!normalized) return false;
+  return IMAGE_QUESTION_RE.test(normalized);
+}
+
+function isExplicitBrowserTabQuestion(content: string): boolean {
+  const normalized = content.trim();
+  if (!normalized) return false;
+  return BROWSER_TAB_RE.test(normalized);
+}
+
+export interface MediaToolPolicy {
+  blockedTools?: string[];
+  prioritizeVisionTool: boolean;
+}
+
+export function resolveMediaToolPolicy(content: string, media: MediaContextItem[]): MediaToolPolicy {
+  if (media.length === 0) {
+    return {
+      blockedTools: undefined,
+      prioritizeVisionTool: false,
+    };
+  }
+
+  const imageQuestion = isImageQuestion(content);
+  const explicitBrowserTab = isExplicitBrowserTabQuestion(content);
+  if (imageQuestion && !explicitBrowserTab) {
+    return {
+      blockedTools: ['browser_vision'],
+      prioritizeVisionTool: true,
+    };
+  }
+
+  return {
+    blockedTools: undefined,
+    prioritizeVisionTool: false,
+  };
+}
+
 function resolveGitCommitShort(): string | null {
   if (cachedGitCommitShort !== undefined) return cachedGitCommitShort;
   try {
@@ -1098,6 +1202,7 @@ export async function handleGatewayMessage(req: GatewayChatRequest): Promise<Gat
   const enableRag = req.enableRag ?? session.enable_rag === 1;
   const model = req.model ?? session.model ?? HYBRIDAI_MODEL;
   const turnIndex = session.message_count + 1;
+  const media = normalizeMediaContextItems(req.media);
 
   recordAuditEvent({
     sessionId: req.sessionId,
@@ -1119,6 +1224,7 @@ export async function handleGatewayMessage(req: GatewayChatRequest): Promise<Gat
       turnIndex,
       userInput: req.content,
       username: req.username,
+      mediaCount: media.length,
     },
   });
 
@@ -1216,9 +1322,25 @@ export async function handleGatewayMessage(req: GatewayChatRequest): Promise<Gat
       historyEstimatedTokens: estimateTokenCountFromMessages(messages.slice(historyStart)),
     },
   });
+  const mediaPolicy = resolveMediaToolPolicy(req.content, media);
+  if (mediaPolicy.prioritizeVisionTool) {
+    logger.info(
+      {
+        sessionId: req.sessionId,
+        mediaCount: media.length,
+        blockedTools: mediaPolicy.blockedTools || [],
+      },
+      'Routing Discord image question to vision_analyze tool',
+    );
+  }
+  const mediaContextBlock = buildMediaPromptContext(media);
+  const expandedUserContent = expandSkillInvocation(req.content, skills);
+  const agentUserContent = mediaContextBlock
+    ? `${expandedUserContent}\n\n${mediaContextBlock}`
+    : expandedUserContent;
   messages.push({
     role: 'user',
-    content: expandSkillInvocation(req.content, skills),
+    content: agentUserContent,
   });
 
   try {
@@ -1233,9 +1355,11 @@ export async function handleGatewayMessage(req: GatewayChatRequest): Promise<Gat
       req.channelId,
       scheduledTasks,
       undefined,
+      mediaPolicy.blockedTools,
       req.onTextDelta,
       req.onToolProgress,
       req.abortSignal,
+      media,
     );
     const toolExecutions = output.toolExecutions || [];
     emitToolExecutionAuditEvents({

package/src/gateway-types.ts

@@ -55,6 +55,14 @@ export interface GatewayChatRequestBody {
   userId: string;
   username: string | null;
   content: string;
+  media?: Array<{
+    path: string | null;
+    url: string;
+    originalUrl: string;
+    mimeType: string | null;
+    sizeBytes: number;
+    filename: string;
+  }>;
   chatbotId?: string | null;
   model?: string | null;
   enableRag?: boolean;

package/src/gateway.ts

@@ -25,20 +25,18 @@ import {
   renderGatewayCommand,
   runGatewayScheduledTask,
 } from './gateway-service.js';
+import { buildResponseText, formatError, formatInfo } from './channels/discord/delivery.js';
+import { rewriteUserMentionsForMessage } from './channels/discord/mentions.js';
 import { startHealthServer } from './health.js';
 import { startHeartbeat, stopHeartbeat } from './heartbeat.js';
 import { logger } from './logger.js';
 import { startObservabilityIngest, stopObservabilityIngest } from './observability-ingest.js';
 import { startScheduler, stopScheduler } from './scheduler.js';
 import {
-  buildResponseText,
-  formatError,
-  formatInfo,
   initDiscord,
-  rewriteUserMentionsForMessage,
   sendToChannel,
   type ReplyFn,
-} from './discord.js';
+} from './channels/discord/runtime.js';
 import { isWithinActiveHours, proactiveWindowLabel } from './proactive-policy.js';
 import type { ArtifactMetadata } from './types.js';
 
@@ -199,6 +197,7 @@ async function startDiscordIntegration(): Promise<void> {
       userId: string,
       username: string,
       content: string,
+      media,
       _reply: ReplyFn,
       context,
     ) => {
@@ -210,6 +209,7 @@ async function startDiscordIntegration(): Promise<void> {
           userId,
           username,
           content,
+          media,
           onTextDelta: (delta) => {
             void context.stream.append(delta);
           },

package/src/health.ts

@@ -12,9 +12,10 @@ import {
   type GatewayChatRequest,
 } from './gateway-service.js';
 import { type GatewayChatRequestBody } from './gateway-types.js';
+import { type DiscordToolActionRequest } from './channels/discord/tool-actions.js';
+import { runDiscordToolAction } from './channels/discord/runtime.js';
 import { type ToolProgressEvent } from './types.js';
 import { logger } from './logger.js';
-import { runDiscordToolAction, type DiscordToolActionRequest } from './discord.js';
 
 const SITE_DIR = path.resolve(process.cwd(), 'docs');
 const MAX_REQUEST_BYTES = 1_000_000; // 1MB

package/src/heartbeat.ts

@@ -41,6 +41,8 @@ const HEARTBEAT_ALLOWED_TOOLS = [
   'browser_screenshot',
   'browser_pdf',
   'browser_vision',
+  'vision_analyze',
+  'image',
   'browser_get_images',
   'browser_console',
   'browser_network',