mioku-plugin-agent 0.1.0 → 0.2.0

package/README.md

@@ -12,11 +12,11 @@
   - `auto` 自动：文件与命令直接执行，但**每条命令先由工作模型审查**，危险操作（删除用户文件、清库、`git push`、sudo 等）转用户审批；执行通知与审批请求都即时推送
   - `full` 完全访问：不审批，命令与写入/编辑汇总成一条转发记录
   - `yolo` 静默：权限最高且**不推送任何中间通知**，用户只收到最终结果
-- **个人工作区**：每个 QQ 号独立工作区，默认 `data/agent/workspace/<qq号>`
+- **个人工作区**：每个「适配器 + 用户」独立工作区，默认 `data/agent/workspace/<适配器>_<用户id>`（openid 平台同样隔离）
 - **聊天内审批**：非 full 权限档下 bash 命令需 `.agent approve` 批准（不带 id 时处理该用户最近一次请求）；每条命令都必须带 `purpose`，审批与执行告知都会带上用途
 - **操作合并转发**（仅 `full`）：命令、写入、编辑不再逐条推送，而是攒到本轮结束、在最终回复**之前**合并成一条合并转发消息（卡片来源「Agent 执行记录」，外显小字是操作条数与用户请求摘要，总摘要是各类操作计数与失败数；首节点为简介，其余节点按时间顺序记录每条命令/文件改动，含用途、耗时与失败输出）。适配器不支持转发时自动降级为普通文本消息。`read`/`glob`/`grep`/联网/看图等只读操作不记录。`auto` 不合并，仍逐条即时推送
 - **工具面**：read / write / edit / glob / grep / bash / view_image / send_file / send_image / web_search (SearXNG) / web_fetch / todo_write
-- **附件自动下载**：用户发来的图片/文件/音视频统一按文件自动落到 `download/<今天日期>/`，**保留原始文件名与后缀**（`file_name` → segment 的 `file` → `path` → URL 文件名，缺后缀才用 content-type 补）；user 消息里带 `message_id`、`name` 和 `[file://路径]`，图片额外作为图片内容附加给模型。QQ 文件消息只有 `file_id` 时按平台 API（`get_file` / `get_group_file_url` / `get_private_file_url`）换取下载地址与原始文件名
+- **附件自动下载**：用户发来的图片/文件/音视频统一按文件自动落到 `download/<今天日期>/`，**保留原始文件名与后缀**（`file_name` → segment 的 `file` → `path` → URL 文件名，缺后缀才用 content-type 补）；user 消息里带 `message_id`、`name` 和 `[file://路径]`，图片额外作为图片内容附加给模型。文件消息只有 `file_id` 时按平台分支解析下载地址，见下
 - **消息引用**：模型在回复首行写 `[reply:message_id]` 即可引用（回复）指定聊天消息，标记会被移除并只作用于本轮第一条消息
 - **运行中插话**：Agent 正在跑时用户继续发消息，不再排队等下一轮，而是并入**当前请求**的下一次迭代（DSH 式 steering），模型在同一个回复里就能看到并调整；日志里 `steer queued` 表示已入队、`steer merged into running turn` 表示已并入本轮请求
 - **看图**：`view_image` 查看本地图片；多模态主模型直接把图片附加进对话，非多模态时交给视觉模型转成描述

package/commands/index.ts

@@ -4,15 +4,16 @@ import type { SessionPlanItem } from "../db";
 import { maybeCompact } from "../core/compaction";
 import { generateSessionTitle } from "../core/title";
 import { stopAgentTurn } from "../core/loop";
+import { identityOf } from "../core/identity";
 import { PERMISSION_LEVELS } from "../tools/perm";
 
 const CLEAR_CONFIRM_TTL_MS = 60_000;
 
 const resumeListCache = new Map<
-  number,
+  string,
   { generations: number[]; at: number }
 >();
-const pendingClear = new Map<number, number>();
+const pendingClear = new Map<string, number>();
 
 async function reply(event: MessageEvent, text: string): Promise<void> {
   await event.reply(text, true);
@@ -21,12 +22,12 @@ async function reply(event: MessageEvent, text: string): Promise<void> {
 async function requireUser(
   host: AgentHost,
   event: MessageEvent,
-): Promise<number> {
-  const userId = Number(event.user_id || event.sender?.user_id || 0);
-  if (!userId) {
-    await reply(event, "agent 命令需要在 QQ 私聊中使用");
+): Promise<string> {
+  const identity = identityOf(event);
+  if (!identity.userId) {
+    await reply(event, "agent 命令需要在私聊中使用");
   }
-  return userId;
+  return identity.scope;
 }
 
 function formatTime(ts: number): string {
@@ -56,7 +57,7 @@ async function backgroundTitle(
   host.logger.info(`[agent] session ${sessionId} titled: ${title}`);
 }
 
-function cachedResumable(host: AgentHost, userId: number): number[] {
+function cachedResumable(host: AgentHost, userId: string): number[] {
   const cached = resumeListCache.get(userId);
   if (cached && Date.now() - cached.at < 5 * 60_000) return cached.generations;
   const current = host.sessions.sessionId(userId);
@@ -67,7 +68,7 @@ function cachedResumable(host: AgentHost, userId: number): number[] {
   return generations;
 }
 
-function invalidateResumeCache(userId: number): void {
+function invalidateResumeCache(userId: string): void {
   resumeListCache.delete(userId);
 }
 

package/core/compaction.ts

@@ -34,7 +34,7 @@ export interface CompactionResult {
 
 export async function maybeCompact(
   host: AgentHost,
-  userId: number,
+  userId: string,
   options: { force?: boolean } = {},
 ): Promise<CompactionResult> {
   const settings = host.getSettings();

package/core/download.ts

@@ -3,6 +3,8 @@ import * as fsp from "node:fs/promises";
 import * as path from "node:path";
 import type { Bot } from "mioku";
 import type { MediaAttachment, MediaKind } from "./media";
+import type { AgentPlatform } from "../platforms/types";
+import { EMPTY_FILE_LOOKUP } from "../platforms/types";
 
 const MAX_DOWNLOAD_BYTES = 100 * 1024 * 1024;
 const DOWNLOAD_TIMEOUT_MS = 60_000;
@@ -212,52 +214,18 @@ function candidateSources(item: MediaAttachment): string[] {
 async function platformLookup(
   bot: Bot | undefined,
   item: MediaAttachment,
+  platform: AgentPlatform | undefined,
 ): Promise<{ sources: string[]; names: string[] }> {
-  const sources: string[] = [];
-  const names: string[] = [];
-  if (!bot || !item.fileId) return { sources, names };
-
-  const attempts: Array<[string, Record<string, unknown>]> = [
-    ["get_file", { file_id: item.fileId }],
-  ];
-  if (item.groupId) {
-    attempts.push([
-      "get_group_file_url",
-      { group_id: Number(item.groupId), file_id: item.fileId },
-    ]);
-  }
-  if (item.userId) {
-    attempts.push([
-      "get_private_file_url",
-      { user_id: Number(item.userId), file_id: item.fileId },
-    ]);
-  }
-
-  for (const [action, params] of attempts) {
-    try {
-      const result = (await bot.sendApi(action, params)) as Record<
-        string,
-        unknown
-      > | null;
-      if (!result || typeof result !== "object") continue;
-      for (const key of ["url", "file", "path"]) {
-        const value = result[key];
-        if (typeof value === "string" && value.trim())
-          sources.push(value.trim());
-      }
-      const base64 = result.base64 ?? result.data;
-      if (typeof base64 === "string" && base64.trim()) {
-        sources.push(`base64://${base64.trim()}`);
-      }
-      for (const key of ["file_name", "name"]) {
-        const value = result[key];
-        if (typeof value === "string" && value.trim()) names.push(value.trim());
-      }
-    } catch {
-      // 平台不支持该 action 时忽略，继续尝试下一个
-    }
+  if (!bot || !item.fileId || !platform) return EMPTY_FILE_LOOKUP;
+  try {
+    return await platform.resolveFile(bot, {
+      fileId: item.fileId,
+      groupId: item.groupId,
+      userId: item.userId,
+    });
+  } catch {
+    return EMPTY_FILE_LOOKUP;
   }
-  return { sources, names };
 }
 
 function describeFields(item: MediaAttachment): string {
@@ -273,13 +241,14 @@ function describeFields(item: MediaAttachment): string {
 async function resolveSource(
   item: MediaAttachment,
   bot: Bot | undefined,
+  platform: AgentPlatform | undefined,
 ): Promise<{
   buffer: Buffer;
   contentType: string | null;
   fallbackName: string;
 }> {
-  const platform = await platformLookup(bot, item);
-  const candidates = [...candidateSources(item), ...platform.sources];
+  const found = await platformLookup(bot, item, platform);
+  const candidates = [...candidateSources(item), ...found.sources];
   if (candidates.length === 0) {
     throw new Error(`no downloadable source (${describeFields(item)})`);
   }
@@ -290,7 +259,7 @@ async function resolveSource(
       // 平台返回的原始文件名最可信，其次才是 URL 推断出来的名字
       return {
         ...result,
-        fallbackName: platform.names[0] ?? result.fallbackName,
+        fallbackName: found.names[0] ?? result.fallbackName,
       };
     } catch (err) {
       lastError = String(err);
@@ -302,7 +271,7 @@ async function resolveSource(
 export async function downloadMediaItems(
   items: MediaAttachment[],
   workspaceRoot: string,
-  options: { bot?: Bot } = {},
+  options: { bot?: Bot; platform?: AgentPlatform } = {},
 ): Promise<DownloadResult> {
   const dir = path.join(workspaceRoot, "download", dateStamp());
   const files: DownloadedMedia[] = [];
@@ -315,6 +284,7 @@ export async function downloadMediaItems(
       const { buffer, contentType, fallbackName } = await resolveSource(
         item,
         options.bot,
+        options.platform,
       );
       if (buffer.byteLength > MAX_DOWNLOAD_BYTES) {
         errors.push(`#${index + 1} exceeds ${MAX_DOWNLOAD_BYTES} bytes`);

package/core/emotion.ts

@@ -8,7 +8,7 @@ function normalizeName(value: unknown): string {
 
 export class EmotionManager {
   constructor(
-    private readonly store: (userId: number, emotion: string) => void,
+    private readonly store: (userId: string, emotion: string) => void,
   ) {}
 
   available(config: ChatEmotionConfig | null): string[] {
@@ -36,7 +36,7 @@ export class EmotionManager {
   }
 
   setEmotion(
-    userId: number,
+    userId: string,
     emotion: unknown,
     config: ChatEmotionConfig | null,
   ): string {

package/core/identity.ts

@@ -0,0 +1,27 @@
+import type { MessageEvent } from "mioku";
+
+/**
+ * 事件的用户身份。
+ * `userId` 是平台原始 id(QQ 号或 openid),用于权限名单匹配;
+ * `scope` 额外带上适配器,用于会话/工作区/队列隔离,避免不同平台相同 id 串号。
+ */
+export interface AgentIdentity {
+  readonly userId: string;
+  readonly adapter: string;
+  readonly botId: string;
+  readonly scope: string;
+}
+
+export const identityOf = (event: MessageEvent): AgentIdentity => {
+  const userId = String(event?.user_id ?? event?.sender?.user_id ?? "").trim();
+  const adapter = String(
+    event?.bot?.adapter ?? event?.identity?.adapter ?? "",
+  ).trim();
+  const botId = String(event?.self_id ?? event?.bot?.bot_id ?? "").trim();
+  return {
+    userId,
+    adapter,
+    botId,
+    scope: `${adapter || "unknown"}:${userId}`,
+  };
+};

package/core/loop.ts

@@ -12,6 +12,8 @@ import { TurnSender } from "./send";
 import { buildSystemPrompt } from "./prompt";
 import { maybeCompact } from "./compaction";
 import { cleanEmotionMarkers, stripThinkBlocks } from "./units";
+import { identityOf, type AgentIdentity } from "./identity";
+import type { AgentPlatform } from "../platforms/types";
 import { describeImageUrls, extractMedia, formatMediaNote } from "./media";
 import { downloadMediaItems, readImageDataUrl } from "./download";
 import { TurnActivity } from "./activity";
@@ -42,9 +44,9 @@ interface UserQueue {
   controller: AbortController | null;
 }
 
-const queues = new Map<number, UserQueue>();
+const queues = new Map<string, UserQueue>();
 
-function getQueue(userId: number): UserQueue {
+function getQueue(userId: string): UserQueue {
   let queue = queues.get(userId);
   if (!queue) {
     queue = { running: false, inbox: [], controller: null };
@@ -55,7 +57,7 @@ function getQueue(userId: number): UserQueue {
 
 export function stopAgentTurn(
   host: AgentHost,
-  userId: number,
+  userId: string,
 ): { running: boolean; dropped: number; approvals: number } {
   const queue = queues.get(userId);
   const dropped = queue?.inbox.length ?? 0;
@@ -72,29 +74,31 @@ export function stopAgentTurn(
 function kickQueue(
   host: AgentHost,
   event: MessageEvent,
-  userId: number,
+  userId: string,
   queue: UserQueue,
 ): void {
   if (queue.running) return;
   const next = queue.inbox.shift();
   if (!next) return;
   queue.running = true;
-  void drainTurns(host, event, userId, queue, next);
+  void drainTurns(host, event, identityOf(event), queue, next);
 }
 
 export function runAgentTurn(
   host: AgentHost,
   event: MessageEvent,
+  platform: AgentPlatform,
 ): Promise<void> {
-  const userId = Number(event.user_id || event.sender?.user_id || 0);
-  if (!userId) return Promise.resolve();
+  const identity = identityOf(event);
+  if (!identity.userId) return Promise.resolve();
+  const userId = identity.scope;
   const queue = getQueue(userId);
 
   // 先占住轮次再准备输入，保证消息按到达顺序处理
   const ownsTurn = !queue.running;
   if (ownsTurn) queue.running = true;
 
-  return prepareInput(host, event, userId)
+  return prepareInput(host, event, identity, platform)
     .then((input) => {
       if (!input) {
         if (ownsTurn) {
@@ -112,7 +116,7 @@ export function runAgentTurn(
         kickQueue(host, event, userId, queue);
         return;
       }
-      return drainTurns(host, event, userId, queue, input);
+      return drainTurns(host, event, identity, queue, input);
     })
     .catch((err) => {
       if (ownsTurn) {
@@ -126,7 +130,7 @@ export function runAgentTurn(
 async function drainTurns(
   host: AgentHost,
   event: MessageEvent,
-  userId: number,
+  identity: AgentIdentity,
   queue: UserQueue,
   first: PreparedInput,
 ): Promise<void> {
@@ -135,29 +139,31 @@ async function drainTurns(
   try {
     let next: PreparedInput | undefined = first;
     while (next) {
-      await executeTurn(host, event, userId, next, queue, controller.signal);
+      await executeTurn(host, event, identity, next, queue, controller.signal);
       next = queue.inbox.shift();
     }
   } finally {
     queue.controller = null;
     queue.running = false;
-    kickQueue(host, event, userId, queue);
+    kickQueue(host, event, identity.scope, queue);
   }
 }
 
 async function prepareInput(
   host: AgentHost,
   event: MessageEvent,
-  userId: number,
+  identity: AgentIdentity,
+  platform: AgentPlatform,
 ): Promise<PreparedInput | null> {
   const resolved = host.resolveModel();
   const bot = event.bot ?? host.ctx.pickBot(event.self_id);
   const media = extractMedia(event);
   const downloads = await downloadMediaItems(
     media,
-    host.workspaceRoot(userId),
+    host.workspaceRoot(identity.scope),
     {
       bot,
+      platform,
     },
   ).catch((err) => {
     host.logger.warn(`[agent] attachment download failed: ${err}`);
@@ -216,7 +222,7 @@ async function prepareInput(
 
 function steeringMessages(
   host: AgentHost,
-  userId: number,
+  userId: string,
   queue: UserQueue,
 ): AgentChatMessage[] {
   if (queue.inbox.length === 0) return [];
@@ -249,11 +255,13 @@ function steeringContent(
 async function executeTurn(
   host: AgentHost,
   event: MessageEvent,
-  userId: number,
+  identity: AgentIdentity,
   input: PreparedInput,
   queue: UserQueue,
   abortSignal: AbortSignal,
 ): Promise<void> {
+  const userId = identity.scope;
+  const sendUserId = identity.userId;
   const base = host.getBase();
   const settings = host.getSettings();
   const resolved = host.resolveModel();
@@ -263,7 +271,7 @@ async function executeTurn(
   const activity = new TurnActivity(digestMode);
 
   if (!resolved) {
-    await replyError(host, bot, userId, "AI 服务不可用，请先在 WebUI 配置模型");
+    await replyError(host, bot, sendUserId, "AI 服务不可用，请先在 WebUI 配置模型");
     return;
   }
 
@@ -286,7 +294,7 @@ async function executeTurn(
 
   const sendToUser = async (text: string): Promise<void> => {
     if (!bot) return;
-    await bot.sendMessage({ type: "private", user_id: userId }, [
+    await bot.sendMessage({ type: "private", user_id: sendUserId }, [
       host.ctx.segment.text(text),
     ]);
   };
@@ -332,6 +340,7 @@ async function executeTurn(
 
     const { tools, webSearchState } = buildTurnTools(host, {
       userId,
+      sendUserId,
       bot,
       runId,
       reporter,
@@ -390,15 +399,15 @@ async function executeTurn(
     const sender = new TurnSender(
       host,
       bot,
-      userId,
+      sendUserId,
       settings.enableMarkdownScreenshot && Boolean(host.screenshot),
     );
     const usageId = `agent:${sessionRow.sessionId}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
     const usageContext = {
       usageId,
       source: "agent",
-      botId: Number(event?.self_id) || undefined,
-      userId,
+      botId: identity.botId || undefined,
+      userId: sendUserId,
       sessionId: sessionRow.sessionId,
     };
 
@@ -464,7 +473,7 @@ async function executeTurn(
     }
 
     // 批量模式：把本回合的全部操作合并成一条转发记录，放在最终回复之前
-    await flushActivity(host, activity, bot, userId, event);
+    await flushActivity(host, activity, bot, sendUserId, event);
 
     if (settings.stream && !digestMode) {
       await sender.finishStream(finalText);
@@ -483,11 +492,11 @@ async function executeTurn(
     status = "error";
     errorText = String(err);
     host.logger.error(`[agent] turn failed: ${err}`);
-    await flushActivity(host, activity, bot, userId, event);
+    await flushActivity(host, activity, bot, sendUserId, event);
     await replyError(
       host,
       bot,
-      userId,
+      sendUserId,
       `Agent 处理出错：${errorText.slice(0, 300)}`,
     );
   } finally {
@@ -552,15 +561,13 @@ async function flushActivity(
   host: AgentHost,
   activity: TurnActivity,
   bot: Bot | undefined,
-  userId: number,
+  userId: string,
   event: MessageEvent,
 ): Promise<void> {
   if (!bot || activity.total === 0) return;
   const target = { type: "private" as const, user_id: userId };
-  const selfId = String(
-    event.self_id || host.ctx.bot?.bot_id || bot.bot_id || userId,
-  );
-  const nickname = host.ctx.bot?.nickname ?? "Agent";
+  const selfId = String(event.self_id || bot.bot_id || userId);
+  const nickname = bot.nickname ?? "Agent";
   const nodes = activity.buildNodes(host.ctx, selfId, nickname);
   try {
     await bot.sendForward(target, nodes, activity.buildDisplay());
@@ -583,7 +590,7 @@ async function flushActivity(
 async function replyError(
   host: AgentHost,
   bot: Bot | undefined,
-  userId: number,
+  userId: string,
   text: string,
 ): Promise<void> {
   if (!bot) return;

package/core/model.ts

@@ -0,0 +1,179 @@
+import type { AIInstance, AIModelRole, AIService } from "mioku";
+import type { ResolvedModel } from "../types";
+
+const OVERRIDE_INSTANCE_PREFIX = "__agent_override_";
+
+export interface ModelOverride {
+  /** 覆盖模型的全 id（providerId/modelId） */
+  key: string;
+  instanceName: string;
+}
+
+export function splitModelFullId(
+  fullId: string,
+): { providerId: string; modelId: string } | null {
+  const raw = String(fullId ?? "").trim();
+  const index = raw.indexOf("/");
+  if (index <= 0 || index >= raw.length - 1) return null;
+  return { providerId: raw.slice(0, index), modelId: raw.slice(index + 1) };
+}
+
+function instanceName(instance: AIInstance | undefined): string | undefined {
+  const name = (instance as { name?: unknown } | undefined)?.name;
+  return typeof name === "string" && name ? name : undefined;
+}
+
+/** 在现有实例里找跑在指定提供商上的实例，同模型优先。 */
+export function findInstanceByProvider(
+  aiService: AIService,
+  providerId: string,
+  modelId?: string,
+): { name: string; instance: AIInstance } | undefined {
+  if (!providerId) return undefined;
+  const infos = aiService.listInstances?.() ?? [];
+  const info =
+    (modelId
+      ? infos.find(
+          (item) => item.providerId === providerId && item.modelId === modelId,
+        )
+      : undefined) ?? infos.find((item) => item.providerId === providerId);
+  if (!info) return undefined;
+  const instance = aiService.get?.(info.name);
+  return instance ? { name: info.name, instance } : undefined;
+}
+
+function overrideInstanceName(providerId: string, modelId: string): string {
+  const slug = `${providerId}_${modelId}`.replace(/[^A-Za-z0-9_.-]+/g, "_");
+  return `${OVERRIDE_INSTANCE_PREFIX}${slug}`;
+}
+
+/**
+ * 覆盖模型必须跑在它自己的提供商上：实例固定绑定 provider，只改 model 会把别的
+ * 提供商的模型名发给主提供商的 client。优先复用现成实例，否则建一个隐藏实例。
+ */
+export async function prepareModelOverride(
+  aiService: AIService,
+  fullId: string,
+  warn: (message: string) => void,
+): Promise<ModelOverride | undefined> {
+  const parsed = splitModelFullId(fullId);
+  if (!parsed) return undefined;
+  const reused = findInstanceByProvider(
+    aiService,
+    parsed.providerId,
+    parsed.modelId,
+  );
+  if (reused) return { key: fullId, instanceName: reused.name };
+  const name = overrideInstanceName(parsed.providerId, parsed.modelId);
+  if (aiService.get?.(name)) return { key: fullId, instanceName: name };
+  if (!aiService.createInstance) {
+    warn(`覆盖模型 ${fullId} 无法切换提供商：AI 服务不支持 createInstance`);
+    return undefined;
+  }
+  try {
+    await aiService.createInstance({
+      name,
+      providerId: parsed.providerId,
+      modelId: parsed.modelId,
+    });
+    return { key: fullId, instanceName: name };
+  } catch (err) {
+    warn(`覆盖模型 ${fullId} 实例创建失败：${err}`);
+    return undefined;
+  }
+}
+
+export function resolveAgentModel(options: {
+  aiService: AIService;
+  overrideFullId: string;
+  override?: ModelOverride;
+}): ResolvedModel | null {
+  const { aiService, overrideFullId, override } = options;
+  const getByRole = (role: AIModelRole) =>
+    aiService.getInstanceByRole?.(role) ?? aiService.get?.(role);
+  const main = getByRole("main") ?? aiService.getDefault?.();
+  if (!main) return null;
+
+  const bindings = aiService.getRoleBindings?.() ?? {
+    main: undefined,
+    working: undefined,
+    vision: undefined,
+  };
+  const instances = aiService.listInstances?.() ?? [];
+  const models = aiService.listModels?.() ?? [];
+
+  const modelIdOf = (
+    full: string | undefined,
+    instance: AIInstance,
+  ): string => {
+    if (full && full.includes("/")) return full.split("/").slice(1).join("/");
+    const name = instanceName(instance);
+    const info = instances.find(
+      (item) => item.role === name || item.name === name,
+    );
+    return info?.modelId ?? "";
+  };
+
+  const overrideDesc = overrideFullId
+    ? models.find((item) => item.id === overrideFullId)
+    : undefined;
+  const overrideParsed = splitModelFullId(overrideFullId);
+
+  let instance = main;
+  let model = modelIdOf(bindings.main, main);
+  if (overrideFullId && overrideParsed) {
+    const target =
+      (override && override.key === overrideFullId
+        ? aiService.get?.(override.instanceName)
+        : undefined) ??
+      findInstanceByProvider(
+        aiService,
+        overrideParsed.providerId,
+        overrideParsed.modelId,
+      )?.instance;
+    if (target) {
+      // 覆盖模型的提供商可达：用它的实例 + 它的模型
+      instance = target;
+      model = overrideDesc?.modelId ?? overrideParsed.modelId;
+    }
+    // 提供商不可达时退回主模型，绝不把别家的模型名发给主提供商的 client
+  }
+
+  let working = getByRole("working") ?? main;
+  let workingModel = modelIdOf(bindings.working, working);
+  if (!workingModel) {
+    // 没有独立绑定的干活模型：跟随主模型，实例也要跟着换，否则模型与提供商错配
+    working = instance;
+    workingModel = model;
+  }
+
+  let vision = getByRole("vision") ?? working;
+  let visionModel = modelIdOf(bindings.vision, vision);
+  if (!visionModel) {
+    vision = working;
+    visionModel = workingModel;
+  }
+
+  const visionDesc =
+    models.find((item) => item.id === bindings.vision) ||
+    models.find((item) => item.modelId === visionModel);
+  // 有覆盖时，直接吃图片的是覆盖模型，能力要以它为准
+  const isMultimodal = overrideDesc
+    ? (overrideDesc.capabilities?.includes("vision") ?? false)
+    : (visionDesc?.capabilities?.includes("vision") ?? Boolean(visionModel));
+  const mainDesc =
+    overrideDesc ||
+    models.find((item) => item.id === bindings.main) ||
+    models.find((item) => item.modelId === model);
+
+  return {
+    instance,
+    model,
+    working,
+    workingModel,
+    vision,
+    visionModel,
+    isMultimodal,
+    contextWindow: mainDesc?.contextWindow ?? 0,
+  };
+}

package/core/send.ts

@@ -36,7 +36,7 @@ export class TurnSender {
   constructor(
     private host: AgentHost,
     private bot: Bot | undefined,
-    private userId: number,
+    private userId: string,
     private enableScreenshot: boolean,
   ) {}