koishi-plugin-chatluna-studio 1.0.0

package/lib/index.js

@@ -0,0 +1,4579 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CHATLUNA_ERROR_CODE_DOCUMENTATION_URL: () => CHATLUNA_ERROR_CODE_DOCUMENTATION_URL,
+  ChatLunaSessionTracker: () => ChatLunaSessionTracker,
+  Config: () => Config,
+  DEFAULT_MODEL_REQUEST_PAGE_SIZE: () => DEFAULT_MODEL_REQUEST_PAGE_SIZE,
+  DEFAULT_MODEL_REQUEST_RECORD_LIMIT: () => DEFAULT_MODEL_REQUEST_RECORD_LIMIT,
+  DEFAULT_MODEL_REQUEST_RECORD_MAX_BYTES: () => DEFAULT_MODEL_REQUEST_RECORD_MAX_BYTES,
+  FileSystemPresetRepository: () => FileSystemPresetRepository,
+  InMemoryModelRequestRecords: () => InMemoryModelRequestRecords,
+  InMemoryRecordRows: () => InMemoryRecordRows,
+  KoishiDatabaseModelRequestPersistence: () => KoishiDatabaseModelRequestPersistence,
+  MAX_MODEL_REQUEST_PAGE_SIZE: () => MAX_MODEL_REQUEST_PAGE_SIZE,
+  MODEL_REQUEST_FACET_SCAN_LIMIT: () => MODEL_REQUEST_FACET_SCAN_LIMIT,
+  PresetRepositoryError: () => PresetRepositoryError,
+  PresetRuntimeSnapshotTracker: () => PresetRuntimeSnapshotTracker,
+  STUDIO_EVIDENCE_AGGREGATE_IDS: () => STUDIO_EVIDENCE_AGGREGATE_IDS,
+  STUDIO_EVIDENCE_KINDS: () => STUDIO_EVIDENCE_KINDS,
+  ScopeRowIndex: () => ScopeRowIndex,
+  SerialWriteQueue: () => SerialWriteQueue,
+  StudioDomainError: () => StudioDomainError,
+  StudioModelRequestCursorExpiredError: () => StudioModelRequestCursorExpiredError,
+  StudioModelRequestStore: () => StudioModelRequestStore,
+  StudioPresetService: () => StudioPresetService,
+  apply: () => apply,
+  archiveChatLunaModelRequestError: () => archiveChatLunaModelRequestError,
+  buildStudioModelRequestTrajectory: () => buildStudioModelRequestTrajectory,
+  buildStudioModelRequestTrajectoryFromStore: () => buildStudioModelRequestTrajectoryFromStore,
+  countMessageCharacters: () => countMessageCharacters,
+  countToolCallCharacters: () => countToolCallCharacters,
+  countToolDefinitionCharacters: () => countToolDefinitionCharacters,
+  createModelRequestError: () => createModelRequestError,
+  deriveModelRequestVariables: () => deriveModelRequestVariables,
+  estimateModelRequestRecordBytes: () => estimateModelRequestRecordBytes,
+  expressionStableId: () => expressionStableId,
+  findLatestFailedModelRequest: () => findLatestFailedModelRequest,
+  getChatLunaErrorPossibleCauses: () => getChatLunaErrorPossibleCauses,
+  inferModelResponseBodyFormat: () => inferModelResponseBodyFormat,
+  inject: () => inject,
+  installModelRequestCollector: () => installModelRequestCollector,
+  isKnownChatModelRequestUrl: () => isKnownChatModelRequestUrl,
+  isStudioEvidenceAggregateMember: () => isStudioEvidenceAggregateMember,
+  isVirtualOneBotSession: () => isVirtualOneBotSession,
+  linkChatLunaUsageRequest: () => linkChatLunaUsageRequest,
+  lookupChatLunaUsage: () => lookupChatLunaUsage,
+  matchPresetExpressionEvidence: () => matchPresetExpressionEvidence,
+  matchesModelRequestQuery: () => matchesModelRequestQuery,
+  modelRequestVariableStatusLabel: () => modelRequestVariableStatusLabel,
+  name: () => name,
+  parsePresetSourceDocument: () => parsePresetSourceDocument,
+  presentModelRequestDetail: () => presentModelRequestDetail,
+  presentModelRequestListItem: () => presentModelRequestListItem,
+  projectModelEvidence: () => projectModelEvidence,
+  readChatLunaRequestError: () => readChatLunaRequestError,
+  readStudioModelRequestConversationRecords: () => readStudioModelRequestConversationRecords,
+  readStudioSessionEntities: () => readStudioSessionEntities,
+  registerConsole: () => registerConsole,
+  registerStudioModelRequestModel: () => registerStudioModelRequestModel,
+  resolveChatLunaPluginClass: () => resolveChatLunaPluginClass,
+  resolveConsoleEntry: () => resolveConsoleEntry,
+  resolveModelRequestOrder: () => resolveModelRequestOrder,
+  sanitizeModelRequestUrl: () => sanitizeModelRequestUrl,
+  statusLabel: () => statusLabel,
+  studioEvidenceAggregate: () => studioEvidenceAggregate,
+  studioEvidenceLabels: () => studioEvidenceLabels,
+  toModelRequestRecordHeader: () => toModelRequestRecordHeader,
+  toStudioModelRequestUsage: () => toStudioModelRequestUsage,
+  usage: () => usage
+});
+module.exports = __toCommonJS(index_exports);
+var import_koishi3 = require("koishi");
+
+// src/chatluna/error.ts
+var CHATLUNA_ERROR_CODE_DOCUMENTATION_URL = "https://chatluna.chat/guide/faq/error_code.html";
+var CHATLUNA_ERROR_CAUSES = {
+  1: ["\u7F51\u7EDC\u8FDE\u63A5\u6216\u4EE3\u7406\u914D\u7F6E\u5F02\u5E38\u3002"],
+  2: ["\u4EE3\u7406\u5730\u5740\u6216\u4EE3\u7406\u534F\u8BAE\u65E0\u6548\uFF0C\u8BF7\u68C0\u67E5\u4EE3\u7406 URL \u7684\u534F\u8BAE\u548C\u683C\u5F0F\u3002"],
+  100: ["API Key \u4E0D\u53EF\u7528\u6216\u65E0\u6548\uFF0C\u8BF7\u786E\u8BA4\u5BC6\u94A5\u4ECD\u53EF\u6B63\u5E38\u4F7F\u7528\u3002"],
+  101: ["\u670D\u52A1\u5546\u8981\u6C42\u5B8C\u6210\u9A8C\u8BC1\u7801\uFF0C\u8BF7\u767B\u5F55\u5BF9\u5E94\u670D\u52A1\u624B\u52A8\u9A8C\u8BC1\u3002"],
+  102: ["\u7F51\u7EDC\u8FDE\u63A5\u3001\u4EE3\u7406\u914D\u7F6E\u6216 API Key \u5F02\u5E38\u3002", "\u6A21\u578B\u54CD\u5E94\u8F83\u6162\u3001\u4E0A\u4E0B\u6587\u8F83\u957F\u6216\u4EE3\u7406\u5EF6\u8FDF\u8F83\u9AD8\uFF1B\u786E\u8BA4\u8FD9\u4E9B\u60C5\u51B5\u540E\u53EF\u9002\u5F53\u589E\u52A0\u8D85\u65F6\u65F6\u95F4\u3002"],
+  103: ["\u7F51\u7EDC\u8FDE\u63A5\u3001\u4EE3\u7406\u914D\u7F6E\u6216 API Key \u5F02\u5E38\uFF1B\u8BE5\u9519\u8BEF\u7801\u8986\u76D6\u8303\u56F4\u8F83\u5E7F\uFF0C\u8BF7\u7ED3\u5408\u4E0B\u65B9\u539F\u59CB\u539F\u56E0\u548C\u54CD\u5E94\u539F\u6587\u7EE7\u7EED\u5224\u65AD\u3002"],
+  104: ["\u8BF7\u6C42\u6216\u5BF9\u8BDD\u4E2D\u5305\u542B\u4E0D\u5B89\u5168\u5185\u5BB9\uFF0C\u8BF7\u65B0\u5EFA\u4F1A\u8BDD\u540E\u91CD\u8BD5\u3002"],
+  301: ["\u6A21\u578B\u4E0D\u53EF\u7528\u3001\u6A21\u578B\u540D\u79F0\u4E0D\u5B58\u5728\uFF0C\u6216\u9002\u914D\u5668\u521D\u59CB\u5316\u5931\u8D25\u3002"],
+  303: ["\u6A21\u578B\u521D\u59CB\u5316\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u6A21\u578B\u914D\u7F6E\u548C\u7F51\u7EDC\u8FDE\u63A5\u3002"],
+  307: ["\u5F53\u524D\u6CA1\u6709\u53EF\u7528\u7684\u6A21\u578B\u914D\u7F6E\uFF1B\u53EF\u5148\u65B0\u5EFA\u4F1A\u8BDD\uFF0C\u518D\u68C0\u67E5\u6A21\u578B\u3001\u5D4C\u5165\u6A21\u578B\u548C\u5411\u91CF\u6570\u636E\u5E93\u914D\u7F6E\u3002"],
+  309: ["\u6A21\u578B\u8FD4\u56DE\u7A7A\u54CD\u5E94\uFF1B\u8BF7\u68C0\u67E5 API\u3001\u7F51\u7EDC\u548C\u5BC6\u94A5\uFF0C\u5E76\u786E\u8BA4\u5BF9\u8BDD\u6216\u9884\u8BBE\u5185\u5BB9\u672A\u88AB\u6A21\u578B\u62D2\u7EDD\u3002"]
+};
+function readChatLunaRequestError(error) {
+  const value = readRecord(error);
+  if (!value) return;
+  const code = readFiniteNumber(value.errorCode);
+  const message = readNonEmptyString(value.message);
+  const originMessage = readOriginMessage(value.originError);
+  const isTimeout = value.isTimeout === true;
+  if (code === void 0 && !message && !originMessage && !isTimeout) return;
+  return {
+    ...code !== void 0 ? { code } : {},
+    ...message ? { message } : {},
+    ...originMessage && originMessage !== message ? { originMessage } : {},
+    ...isTimeout ? { isTimeout: true } : {}
+  };
+}
+function getChatLunaErrorPossibleCauses(error) {
+  if (error?.code === void 0) return [];
+  return CHATLUNA_ERROR_CAUSES[error.code] ?? [];
+}
+function findLatestFailedModelRequest(records, conversationId) {
+  const candidates = records.filter((record) => record.status === "error" && !record.chatlunaError).sort((left, right) => right.sequence - left.sequence);
+  if (conversationId) {
+    const matchingConversation = candidates.find((record) => record.entities.conversationId === conversationId);
+    if (matchingConversation) return matchingConversation;
+  }
+  return candidates[0];
+}
+function archiveChatLunaModelRequestError(store, error, target) {
+  const chatlunaError = readChatLunaRequestError(error);
+  if (!chatlunaError) return;
+  const task = store.getRawRecords().then(async (records) => {
+    const record = findLatestFailedModelRequest(records, target.conversationId);
+    if (!record) return;
+    await store.update(record.id, { chatlunaError });
+  }).catch(() => void 0);
+  store.trackUpdate(task);
+}
+function readRecord(value) {
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readOriginMessage(origin) {
+  const record = readRecord(origin);
+  return readNonEmptyString(record?.message) ?? readNonEmptyString(origin);
+}
+
+// src/chatluna/session-tracker.ts
+var import_koishi = require("koishi");
+function readRecord2(value) {
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+function readString(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function readNested(value, path) {
+  let current = value;
+  for (const key of path) current = readRecord2(current)?.[key];
+  return current;
+}
+function readFirstString(value, paths) {
+  for (const path of paths) {
+    const found = readString(readNested(value, path));
+    if (found) return found;
+  }
+}
+function resolveConversationType(session, conversationId) {
+  if (readNested(session, ["isDirect"]) === true) return "private";
+  if (readString(readNested(session, ["subtype"])) === "private") return "private";
+  if (conversationId.startsWith("private:")) return "private";
+  return readFirstString(session, [["guildId"], ["event", "guild", "id"]]) ? "group" : "private";
+}
+function readStudioSessionEntities(session) {
+  const botId = readFirstString(session, [["selfId"], ["bot", "selfId"], ["bot", "userId"]]);
+  const conversationId = readFirstString(session, [["channelId"], ["channel", "id"], ["event", "channel", "id"]]);
+  if (!botId || !conversationId) return;
+  const platform = readFirstString(session, [["platform"], ["bot", "platform"]]);
+  const botName = readFirstString(session, [["bot", "user", "name"], ["bot", "user", "nick"], ["bot", "nickname"]]);
+  const guildId = readFirstString(session, [["guildId"], ["event", "guild", "id"]]);
+  const userId = readFirstString(session, [["userId"], ["author", "id"], ["event", "user", "id"]]);
+  const conversationName = readFirstString(session, [
+    ["channel", "name"],
+    ["event", "channel", "name"],
+    ["guild", "name"],
+    ["event", "guild", "name"]
+  ]);
+  const userName = readFirstString(session, [
+    ["author", "nick"],
+    ["author", "nickname"],
+    ["author", "name"],
+    ["username"],
+    ["event", "user", "name"]
+  ]);
+  return {
+    ...platform ? { platform } : {},
+    botId,
+    ...botName ? { botName } : {},
+    conversationId,
+    ...conversationName ? { conversationName } : {},
+    conversationType: resolveConversationType(session, conversationId),
+    ...guildId ? { guildId } : {},
+    ...userId ? { userId } : {},
+    ...userName ? { userName } : {}
+  };
+}
+function isVirtualOneBotSession(session) {
+  if (readNested(session, ["bot", "hidden"]) !== true) return false;
+  return readFirstString(session, [["bot", "platform"], ["platform"]]) === "onebot";
+}
+var ChatLunaSessionTracker = class {
+  constructor(ctx, options = {}) {
+    this.options = options;
+    const on = ctx.on.bind(ctx);
+    this.disposers.push(on("chatluna/before-chat", (conversationId, _message, _variables, _chatInterface, session) => {
+      const key = this.begin(session);
+      if (!key) return;
+      const keys = this.coreKeys.get(conversationId) ?? /* @__PURE__ */ new Set();
+      keys.add(key);
+      this.coreKeys.set(conversationId, keys);
+    }));
+    this.disposers.push(on("chatluna/after-chat", (conversationId, _source, _response, _variables, _chatInterface, session) => {
+      this.finishCore(conversationId, session);
+    }));
+    this.disposers.push(on("chatluna/after-chat-error", (error, conversationId) => {
+      const turn = this.resolveCoreTurn(conversationId);
+      if (turn && !turn.virtual) this.options.onTurnFailed?.(error, turn);
+      this.finishCore(conversationId);
+    }));
+    this.disposers.push(on("chatluna_character/before-chat", (payload) => {
+      this.begin(readRecord2(payload)?.session);
+    }));
+    this.disposers.push(on("chatluna_character/after-chat", (payload) => {
+      this.finish(readRecord2(payload)?.session);
+    }));
+  }
+  options;
+  /** 正在进行的对话轮，按（机器人，会话）索引；同一会话重复开始时以后一次为准。 */
+  turns = /* @__PURE__ */ new Map();
+  /**
+   * ChatLuna 内部会话标识到本地键的映射。
+   *
+   * 核心链路的结束事件只带内部会话标识，不带 session：出错时 `after-chat-error` 连 session
+   * 都没有，只有这张映射能把它还原成具体的（机器人，会话）。
+   */
+  coreKeys = /* @__PURE__ */ new Map();
+  disposers = [];
+  /** 内部会话标识唯一对应一轮时才认；映射到多轮时这次错误归属不明。 */
+  resolveCoreTurn(conversationId) {
+    const keys = this.coreKeys.get(conversationId);
+    if (keys?.size !== 1) return;
+    const [key] = keys;
+    return key ? this.turns.get(key) : void 0;
+  }
+  /**
+   * 归属候选，外加「这次请求是否确定来自虚拟机器人」。
+   *
+   * 归属恰好一轮时才交出：多轮并发或没有任何一轮在跑时，这次模型请求归属不明。
+   *
+   * `virtualOnly` 只在「在跑的对话轮非空且全部虚拟」时为真。虚拟轮与真实轮并发时它为假：fetch
+   * 边界分不出这次请求是哪一边发的，把整对都丢掉会连真实会话的证据一起丢，只能记成未归属留给
+   * 人工按时间对照。反过来两轮都虚拟时不能只看「恰好一轮」，否则模拟环境里跑多轮就又漏进来了。
+   *
+   * 判定留在这里而不是采集器里：采集器只知道「拿到候选就写归属」，而「几轮算可判定」「哪种机器人
+   * 不该记」都是会话跟踪自己的规则，两个模块因此不必共享一份并发假设。
+   */
+  resolveActiveTurn() {
+    const active = [...this.turns.values()];
+    const virtualOnly = active.length > 0 && active.every(({ virtual }) => virtual);
+    if (active.length !== 1) return { virtualOnly };
+    const [turn] = active;
+    if (!turn || turn.virtual) return { virtualOnly };
+    return { virtualOnly, turn: { entities: { ...turn.entities }, interactionId: turn.interactionId } };
+  }
+  /** 当前正在进行的对话轮数；诊断与测试用。 */
+  get activeTurnCount() {
+    return this.turns.size;
+  }
+  dispose() {
+    for (const dispose of this.disposers.splice(0)) dispose();
+    this.turns.clear();
+    this.coreKeys.clear();
+  }
+  begin(session) {
+    const entities = readStudioSessionEntities(session);
+    if (!entities) return;
+    const key = turnKey(entities);
+    const existing = this.turns.get(key);
+    this.turns.set(key, {
+      entities,
+      interactionId: existing?.interactionId ?? import_koishi.Random.id(),
+      virtual: isVirtualOneBotSession(session)
+    });
+    return key;
+  }
+  finish(session) {
+    const entities = readStudioSessionEntities(session);
+    if (entities) this.turns.delete(turnKey(entities));
+  }
+  finishCore(conversationId, session) {
+    const entities = readStudioSessionEntities(session);
+    if (entities) {
+      const key = turnKey(entities);
+      this.turns.delete(key);
+      const keys2 = this.coreKeys.get(conversationId);
+      keys2?.delete(key);
+      if (keys2 && !keys2.size) this.coreKeys.delete(conversationId);
+      return;
+    }
+    const keys = this.coreKeys.get(conversationId);
+    if (!keys) return;
+    if (keys.size === 1) for (const key of keys) this.turns.delete(key);
+    this.coreKeys.delete(conversationId);
+  }
+};
+function turnKey(entities) {
+  return `${entities.botId ?? ""}\0${entities.conversationId ?? ""}`;
+}
+
+// src/chatluna/usage.ts
+var USAGE_MATCH_WINDOW_MS = 6e4;
+function toStudioModelRequestUsage(row) {
+  return {
+    inputTokens: row.inputTokens,
+    outputTokens: row.outputTokens,
+    reasoningTokens: row.reasoningTokens,
+    cachedTokens: row.cachedTokens,
+    totalTokens: row.totalTokens,
+    ...row.ttftMs != null ? { ttftMs: row.ttftMs } : {},
+    ...row.totalMs != null ? { totalMs: row.totalMs } : {},
+    ...row.tps != null ? { tps: row.tps } : {},
+    ...row.estimated !== void 0 ? { estimated: row.estimated } : {},
+    source: "chatluna-usage"
+  };
+}
+async function linkChatLunaUsageRequest(stores, payload) {
+  const requestId = payload.context?.requestId?.trim();
+  if (!requestId) return;
+  const createdAt = payload.createdAt ? Date.parse(String(payload.createdAt)) : Date.now();
+  let best;
+  for (const store of stores) {
+    for (const record of await store.getRawRecords({ limit: 50 })) {
+      if (record.chatlunaRequestId) continue;
+      const delta = Math.abs(Date.parse(record.createdAt) - createdAt);
+      if (!Number.isFinite(delta) || delta > USAGE_MATCH_WINDOW_MS) continue;
+      const modelScore = modelsOverlap(record.model, payload.model) ? 0 : 1e4;
+      const score = delta + modelScore;
+      if (!best || score < best.score) best = { store, record, score };
+    }
+  }
+  if (!best) return;
+  best.store.update(best.record.id, { chatlunaRequestId: requestId });
+  return best.record.id;
+}
+async function lookupChatLunaUsage(service, record) {
+  if (!service) return;
+  const createdAt = Date.parse(record.createdAt);
+  if (!Number.isFinite(createdAt)) return;
+  const listed = await service.list({
+    start: new Date(createdAt - 3e4),
+    end: new Date(createdAt + Math.max(record.durationMs, 0) + 3e4),
+    pageSize: 50,
+    listSortBy: "createdAt",
+    listDesc: true
+  });
+  const rows = listed.rows ?? [];
+  const matched = record.chatlunaRequestId ? rows.find((row2) => row2.requestId === record.chatlunaRequestId) : void 0;
+  const row = matched ?? pickClosestUsageRow(rows, record);
+  return row ? toStudioModelRequestUsage(row) : void 0;
+}
+function pickClosestUsageRow(rows, record) {
+  const createdAt = Date.parse(record.createdAt);
+  let best;
+  for (const row of rows) {
+    const delta = Math.abs(Date.parse(String(row.createdAt)) - createdAt);
+    if (!Number.isFinite(delta) || delta > USAGE_MATCH_WINDOW_MS) continue;
+    const score = delta + (modelsOverlap(record.model, row.model) ? 0 : 1e4);
+    if (!best || score < best.score) best = { row, score };
+  }
+  return best?.row;
+}
+function modelsOverlap(left, right) {
+  if (!left || !right) return false;
+  return left === right || left.includes(right) || right.includes(left);
+}
+
+// src/console.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/model-request.ts
+var import_koishi2 = require("koishi");
+
+// src/model-evidence/shared.ts
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringValue(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function stringifyValue(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function source(region, path, value) {
+  return { region, path, value };
+}
+function evidenceId(region, kind, path) {
+  return `${region === "request" ? "req" : "res"}:${kind}:${path.join(".")}`;
+}
+function semanticText(parts) {
+  return parts.filter((part) => part.kind === "text" || part.kind === "other").map((part) => part.value).join("\n");
+}
+function mediaSource(value) {
+  if (typeof value === "string") return value;
+  if (!isRecord(value)) return void 0;
+  if (typeof value.url === "string") return value.url;
+  if (typeof value.data === "string") {
+    const mimeType = stringValue(value.media_type) ?? stringValue(value.mimeType) ?? stringValue(value.mediaType);
+    return mimeType ? `data:${mimeType};base64,${value.data}` : value.data;
+  }
+}
+function normalizeContentParts(value) {
+  if (typeof value === "string") return [{ kind: "text", value }];
+  if (isRecord(value)) {
+    if (Array.isArray(value.parts)) return normalizeContentParts(value.parts);
+    return normalizeContentParts([value]);
+  }
+  if (!Array.isArray(value)) return value === void 0 ? [] : [{ kind: "other", value: stringifyValue(value) }];
+  return value.flatMap((item) => {
+    if (typeof item === "string") return [{ kind: "text", value: item }];
+    if (!isRecord(item)) return [];
+    if (isRecord(item.inlineData) || isRecord(item.fileData)) return normalizeGeminiPart(item);
+    const text = item.text ?? item.output_text ?? item.content;
+    if (typeof text === "string") return [{ kind: "text", value: text }];
+    const type = typeof item.type === "string" ? item.type.toLowerCase() : "";
+    const mimeType = stringValue(item.mediaType) ?? stringValue(item.mimeType) ?? stringValue(item.media_type);
+    const media = mediaSource(item.image_url ?? item.image ?? item.source ?? item.url ?? item.data);
+    if (type.includes("image") || mimeType?.startsWith("image/") || item.image_url || item.image) {
+      return [{ kind: "image", value: media ?? "[\u56FE\u7247]", ...mimeType ? { mimeType } : {} }];
+    }
+    if (type.includes("file") || mimeType && !mimeType.startsWith("image/")) {
+      return [{ kind: "file", value: media ?? "[\u6587\u4EF6]", ...mimeType ? { mimeType } : {} }];
+    }
+    if (type.includes("audio")) return [{ kind: "audio", value: media ?? "[\u97F3\u9891]", ...mimeType ? { mimeType } : {} }];
+    if (type.includes("video")) return [{ kind: "video", value: media ?? "[\u89C6\u9891]", ...mimeType ? { mimeType } : {} }];
+    return [{ kind: "other", value: stringifyValue(item) }];
+  });
+}
+function normalizeGeminiPart(value) {
+  if (!isRecord(value)) return [];
+  if (typeof value.text === "string") return [{ kind: "text", value: value.text }];
+  if (isRecord(value.inlineData)) {
+    const mimeType = stringValue(value.inlineData.mimeType);
+    const data = typeof value.inlineData.data === "string" ? value.inlineData.data : "";
+    if (mimeType?.startsWith("image/") && mimeType !== "image/svg+xml") {
+      return [{ kind: "image", value: `data:${mimeType};base64,${data}`, mimeType }];
+    }
+    return [{
+      kind: mimeType?.startsWith("audio/") ? "audio" : mimeType?.startsWith("video/") ? "video" : "file",
+      value: data || "[\u5185\u8054\u6587\u4EF6]",
+      ...mimeType ? { mimeType } : {}
+    }];
+  }
+  if (isRecord(value.fileData)) {
+    const mimeType = stringValue(value.fileData.mimeType);
+    const media = stringValue(value.fileData.fileUri) ?? "[\u6587\u4EF6]";
+    return [{
+      kind: mimeType?.startsWith("image/") ? "image" : mimeType?.startsWith("audio/") ? "audio" : mimeType?.startsWith("video/") ? "video" : "file",
+      value: media,
+      ...mimeType ? { mimeType } : {}
+    }];
+  }
+  return [{ kind: "other", value: stringifyValue(value) }];
+}
+function normalizeToolOutput(value) {
+  if (isRecord(value) && value.type === "json" && "value" in value) return stringifyValue(value.value);
+  if (isRecord(value) && value.type === "text" && typeof value.value === "string") return value.value;
+  return stringifyValue(value ?? "");
+}
+function readCallId(value) {
+  return stringValue(value.tool_call_id) ?? stringValue(value.toolCallId) ?? stringValue(value.call_id) ?? stringValue(value.callId) ?? stringValue(value.tool_use_id);
+}
+function readCallObjectId(value) {
+  return readCallId(value) ?? stringValue(value.id);
+}
+function readToolName(value) {
+  return stringValue(value.name) ?? stringValue(value.toolName) ?? stringValue(value.tool_name);
+}
+
+// src/model-evidence/request.ts
+var SYSTEM_FIELDS = ["system", "systemInstruction", "system_instruction", "instructions"];
+var PRIMARY_CONTAINERS = ["messages", "contents", "input"];
+var ANTHROPIC_BLOCK_TYPES = /* @__PURE__ */ new Set(["thinking", "redacted_thinking", "tool_use", "tool_result"]);
+function projectRequestEvidence(body) {
+  const evidence = { messages: [], toolDefinitions: [], diagnostics: [] };
+  if (body === void 0) return evidence;
+  if (!isRecord(body)) {
+    evidence.diagnostics.push(unsupported([], body));
+    return evidence;
+  }
+  let systemCount = 0;
+  for (const [field, value] of Object.entries(body)) {
+    if (!isSystemField(field) || value === void 0 || value === null) continue;
+    systemCount += projectSystemField(field, value, evidence);
+  }
+  const containers = PRIMARY_CONTAINERS.filter((name2) => isPrimaryContainer(name2, body[name2]));
+  const [primary, ...ambiguous] = containers;
+  for (const name2 of ambiguous) {
+    evidence.diagnostics.push({
+      code: "request-container-ambiguous",
+      severity: "warning",
+      source: source("request", [name2], body[name2])
+    });
+  }
+  if (primary === "messages") projectMessagesContainer(body.messages, evidence);
+  else if (primary === "contents") projectGeminiContents(body.contents, evidence);
+  else if (primary === "input") projectResponsesInput(body.input, evidence);
+  for (const [field, value] of Object.entries(body)) {
+    if (field === "tools" || field === "functions") collectToolDefinitions(field, value, evidence.toolDefinitions);
+  }
+  if (!primary && !systemCount) evidence.diagnostics.push(unsupported([], body));
+  return evidence;
+}
+function unsupported(path, value) {
+  return { code: "request-body-unsupported", severity: "warning", source: source("request", path, value) };
+}
+function isSystemField(field) {
+  return SYSTEM_FIELDS.includes(field);
+}
+function isPrimaryContainer(name2, value) {
+  if (name2 === "input") return Array.isArray(value) || typeof value === "string" || isRecord(value);
+  return Array.isArray(value);
+}
+function projectSystemField(field, value, evidence) {
+  const container = isRecord(value) && Array.isArray(value.parts) ? { values: value.parts, path: [field, "parts"] } : Array.isArray(value) ? { values: value, path: [field] } : void 0;
+  if (!container) {
+    evidence.messages.push(createMessage("system", normalizeContentParts(value), [field], value));
+    return 1;
+  }
+  for (const [index, item] of container.values.entries()) {
+    evidence.messages.push(createMessage("system", normalizeContentParts(item), [...container.path, String(index)], item));
+  }
+  return container.values.length;
+}
+function projectMessagesContainer(list, evidence) {
+  for (const [index, value] of list.entries()) {
+    const path = ["messages", String(index)];
+    if (!isRecord(value)) {
+      evidence.diagnostics.push(unsupported(path, value));
+      continue;
+    }
+    if (Array.isArray(value.parts)) {
+      projectTypedPartsMessage(value, path, evidence);
+      continue;
+    }
+    projectRoleMessage(value, path, evidence);
+  }
+}
+function projectRoleMessage(value, path, evidence) {
+  const role = stringValue(value.role)?.toLowerCase() ?? "user";
+  const blocks = Array.isArray(value.content) ? value.content : void 0;
+  const anthropic = Boolean(blocks?.some((block) => isRecord(block) && ANTHROPIC_BLOCK_TYPES.has(String(block.type))));
+  if (role === "assistant" || anthropic) {
+    projectBlockMessage(value, path, role === "assistant" ? "assistant" : normalizeRole(role), blocks, evidence);
+    return;
+  }
+  if (role === "tool" || role === "function" || value.tool_call_id !== void 0) {
+    const parts = normalizeContentParts(value.content ?? value.output);
+    evidence.messages.push(createToolResultMessage(parts, path, value));
+    return;
+  }
+  evidence.messages.push(createMessage(
+    normalizeRole(role),
+    normalizeContentParts(value.content),
+    path,
+    value,
+    explicitReasoning(value),
+    projectToolCallFields(value, path)
+  ));
+}
+function projectBlockMessage(value, path, role, blocks, evidence) {
+  if (!blocks) {
+    evidence.messages.push(createMessage(
+      role,
+      normalizeContentParts(value.content),
+      path,
+      value,
+      explicitReasoning(value),
+      projectToolCallFields(value, path)
+    ));
+    return;
+  }
+  const segments = createSegmentWriter(evidence, role, path, "content", value);
+  for (const text of explicitReasoning(value)) segments.addReasoning(text);
+  for (const call of projectToolCallFields(value, path)) segments.addToolCall(call);
+  for (const [index, block] of blocks.entries()) {
+    const blockPath = [...path, "content", String(index)];
+    if (!isRecord(block)) {
+      segments.push(index, block, normalizeContentParts(block));
+      continue;
+    }
+    const type = String(block.type ?? "");
+    if (type === "thinking" || type === "redacted_thinking") {
+      segments.open(index, block);
+      segments.addReasoning(stringValue(block.thinking) ?? stringValue(block.data));
+      continue;
+    }
+    if (type === "tool_use") {
+      segments.open(index, block);
+      segments.addToolCall(createToolCall(block, blockPath, block.input, { ownsCallId: true }));
+      continue;
+    }
+    if (type === "tool_result") {
+      segments.cut(createToolResultMessage(normalizeContentParts(block.content), blockPath, block, { ownsCallId: true }));
+      continue;
+    }
+    segments.push(index, block, normalizeContentParts([block]));
+  }
+  segments.finish();
+}
+function projectTypedPartsMessage(value, path, evidence) {
+  const role = normalizeRole(stringValue(value.role)?.toLowerCase() ?? "user");
+  const parts = value.parts;
+  const segments = createSegmentWriter(evidence, role, path, "parts", value);
+  for (const [index, part] of parts.entries()) {
+    const partPath = [...path, "parts", String(index)];
+    if (!isRecord(part)) {
+      segments.push(index, part, normalizeContentParts(part));
+      continue;
+    }
+    const type = stringValue(part.type)?.toLowerCase() ?? "";
+    if (type === "tool-result" || type === "tool-output") {
+      const output = part.output ?? part.result ?? part.content;
+      segments.cut(createToolResultMessage(
+        [{ kind: "text", value: normalizeToolOutput(output) }],
+        partPath,
+        part
+      ));
+      continue;
+    }
+    if (type === "reasoning" || type === "reasoning-part") {
+      segments.open(index, part);
+      segments.addReasoning(stringValue(part.text));
+      continue;
+    }
+    if (type === "tool-call" || type === "tool-invocation" || type === "dynamic-tool") {
+      const invocation = isRecord(part.toolInvocation) ? part.toolInvocation : part;
+      segments.open(index, part);
+      segments.addToolCall(createToolCall(
+        invocation,
+        partPath,
+        invocation.input ?? invocation.args ?? invocation.arguments
+      ));
+      continue;
+    }
+    segments.push(index, part, normalizeContentParts([part]));
+  }
+  segments.finish();
+}
+function projectGeminiContents(list, evidence) {
+  for (const [index, value] of list.entries()) {
+    const path = ["contents", String(index)];
+    if (!isRecord(value)) {
+      evidence.diagnostics.push(unsupported(path, value));
+      continue;
+    }
+    const role = value.role === "model" ? "assistant" : "user";
+    const parts = Array.isArray(value.parts) ? value.parts : [];
+    const segments = createSegmentWriter(evidence, role, path, "parts", value);
+    for (const [partIndex, part] of parts.entries()) {
+      if (!isRecord(part)) {
+        segments.push(partIndex, part, []);
+        continue;
+      }
+      if (isRecord(part.functionCall)) {
+        const callPath = [...path, "parts", String(partIndex), "functionCall"];
+        segments.open(partIndex, part);
+        segments.addToolCall(createToolCall(part.functionCall, callPath, part.functionCall.args ?? {}, { ownsCallId: true }));
+        continue;
+      }
+      if (isRecord(part.functionResponse)) {
+        const responsePath = [...path, "parts", String(partIndex), "functionResponse"];
+        const response = part.functionResponse.response ?? part.functionResponse;
+        segments.cut(createToolResultMessage(
+          normalizeContentParts(response),
+          responsePath,
+          part.functionResponse,
+          { ownsCallId: true }
+        ));
+        continue;
+      }
+      segments.push(partIndex, part, normalizeGeminiPart(part));
+    }
+    segments.finish();
+  }
+}
+function projectResponsesInput(input, evidence) {
+  if (typeof input === "string") {
+    evidence.messages.push(createMessage("user", normalizeContentParts(input), ["input"], input));
+    return;
+  }
+  if (isRecord(input)) {
+    projectResponsesInputItem(input, ["input"], evidence);
+    return;
+  }
+  if (!Array.isArray(input)) return;
+  for (const [index, value] of input.entries()) {
+    const path = ["input", String(index)];
+    if (!isRecord(value)) {
+      evidence.messages.push(createMessage("user", [{ kind: "text", value: String(value) }], path, value));
+      continue;
+    }
+    projectResponsesInputItem(value, path, evidence);
+  }
+}
+function projectResponsesInputItem(value, path, evidence) {
+  {
+    const type = stringValue(value.type);
+    if (type === "function_call") {
+      evidence.messages.push(createMessage(
+        "assistant",
+        [],
+        path,
+        value,
+        [],
+        [createToolCall(value, path, value.arguments ?? value.args ?? value.input)]
+      ));
+      return;
+    }
+    if (type === "function_call_output") {
+      evidence.messages.push(createToolResultMessage(
+        normalizeContentParts(value.output ?? value.result ?? value.content),
+        path,
+        value
+      ));
+      return;
+    }
+    evidence.messages.push(createMessage(
+      normalizeRole(stringValue(value.role)?.toLowerCase() ?? "user"),
+      normalizeContentParts(value.content ?? value.input),
+      path,
+      value,
+      explicitReasoning(value),
+      projectToolCallFields(value, path)
+    ));
+  }
+}
+function createSegmentWriter(evidence, role, path, container, value) {
+  const emissions = [];
+  let parts = [];
+  let reasoning = [];
+  let toolCalls = [];
+  let sources = [];
+  const open2 = (index, item) => {
+    sources.push(source("request", [...path, container, String(index)], item));
+  };
+  const flush = () => {
+    if (!parts.length && !reasoning.length && !toolCalls.length) return;
+    emissions.push({ type: "segment", parts, reasoning, toolCalls, sources });
+    parts = [];
+    reasoning = [];
+    toolCalls = [];
+    sources = [];
+  };
+  return {
+    addReasoning: (text) => {
+      if (text) reasoning.push(text);
+    },
+    addToolCall: (call) => {
+      if (!sources.length) sources.push(source("request", path, value));
+      toolCalls.push(call);
+    },
+    open: open2,
+    push: (index, item, incoming) => {
+      open2(index, item);
+      parts.push(...incoming);
+    },
+    cut: (message) => {
+      flush();
+      emissions.push({ type: "message", message });
+    },
+    finish: () => {
+      flush();
+      const single = emissions.length === 1 && emissions[0]?.type === "segment";
+      for (const emission of emissions) {
+        if (emission.type === "message") {
+          evidence.messages.push(emission.message);
+          continue;
+        }
+        const segmentSources = single ? [source("request", path, value)] : emission.sources;
+        evidence.messages.push(createMessageFromSources(
+          role,
+          emission.parts,
+          segmentSources[0]?.path ?? path,
+          segmentSources.length ? segmentSources : [source("request", path, value)],
+          emission.reasoning,
+          emission.toolCalls
+        ));
+      }
+    }
+  };
+}
+function normalizeRole(role) {
+  if (role === "assistant") return "assistant";
+  if (role === "system" || role === "developer") return "system";
+  if (role === "tool" || role === "function") return "tool";
+  return "user";
+}
+function explicitReasoning(value) {
+  return [value.reasoning_content, value.reasoning].filter((item) => typeof item === "string" && item.length > 0);
+}
+function projectToolCallFields(value, path) {
+  const calls = [];
+  for (const field of ["tool_calls", "toolCalls"]) {
+    const list = value[field];
+    if (!Array.isArray(list)) continue;
+    for (const [index, item] of list.entries()) {
+      if (!isRecord(item)) continue;
+      const callPath = [...path, field, String(index)];
+      const fn = isRecord(item.function) ? item.function : item;
+      calls.push(createToolCall(item, callPath, fn.arguments ?? fn.input ?? fn.args, { nameCarrier: fn, ownsCallId: true }));
+    }
+  }
+  if (isRecord(value.function_call)) {
+    calls.push(createToolCall(value.function_call, [...path, "function_call"], value.function_call.arguments));
+  }
+  return calls;
+}
+function createToolCall(raw, path, argumentsValue, options = {}) {
+  const nameCarrier = options.nameCarrier ?? raw;
+  const callId = options.ownsCallId ? readCallObjectId(raw) : readCallId(raw);
+  const name2 = readToolName(nameCarrier) ?? readToolName(raw) ?? "\u5DE5\u5177\u8C03\u7528";
+  const args = argumentsValue === void 0 ? void 0 : typeof argumentsValue === "string" ? argumentsValue : stringifyValue(argumentsValue);
+  return {
+    evidenceId: evidenceId("request", "tool-call", path),
+    name: name2,
+    ...callId ? { callId } : {},
+    ...args !== void 0 ? { arguments: args } : {},
+    sources: [source("request", path, raw)]
+  };
+}
+function createToolResultMessage(parts, path, raw, options = {}) {
+  const record = isRecord(raw) ? raw : {};
+  const callId = options.ownsCallId ? readCallObjectId(record) : readCallId(record);
+  const toolName = readToolName(record);
+  return {
+    evidenceId: evidenceId("request", "message", path),
+    role: "tool",
+    text: semanticText(parts),
+    contentParts: parts,
+    toolCalls: [],
+    ...callId ? { toolCallId: callId } : {},
+    ...toolName ? { toolName } : {},
+    sources: [source("request", path, raw)]
+  };
+}
+function createMessage(role, parts, path, raw, reasoning = [], toolCalls = []) {
+  return createMessageFromSources(role, parts, path, [source("request", path, raw)], reasoning, toolCalls);
+}
+function createMessageFromSources(role, parts, idPath, sources, reasoning = [], toolCalls = []) {
+  const reasoningText = reasoning.filter(Boolean).join("\n");
+  return {
+    evidenceId: evidenceId("request", "message", idPath),
+    role,
+    text: semanticText(parts),
+    contentParts: parts,
+    ...reasoningText ? { reasoning: reasoningText } : {},
+    toolCalls,
+    sources
+  };
+}
+function collectToolDefinitions(field, value, target) {
+  if (Array.isArray(value)) {
+    for (const [index, item] of value.entries()) {
+      if (!isRecord(item)) continue;
+      if (Array.isArray(item.functionDeclarations)) {
+        for (const [declarationIndex, declaration] of item.functionDeclarations.entries()) {
+          if (!isRecord(declaration)) continue;
+          target.push(createToolDefinition(declaration, [field, String(index), "functionDeclarations", String(declarationIndex)]));
+        }
+        continue;
+      }
+      const definition = isRecord(item.function) ? item.function : item;
+      target.push(createToolDefinition(definition, [field, String(index), ...isRecord(item.function) ? ["function"] : []]));
+    }
+    return;
+  }
+  if (!isRecord(value)) return;
+  for (const [name2, definition] of Object.entries(value)) {
+    if (!isRecord(definition)) continue;
+    target.push(createToolDefinition({ name: name2, ...definition }, [field, name2]));
+  }
+}
+function createToolDefinition(value, path) {
+  const parameters = value.parameters ?? value.input_schema ?? value.inputSchema ?? value.parametersJsonSchema;
+  const schema = isRecord(parameters) ? parameters : void 0;
+  const properties = isRecord(schema?.properties) ? schema.properties : void 0;
+  const requiredFields = Array.isArray(schema?.required) ? schema.required.filter((entry) => typeof entry === "string") : [];
+  return {
+    evidenceId: evidenceId("request", "tool-definition", path),
+    name: stringValue(value.name) ?? "\u672A\u547D\u540D\u5DE5\u5177",
+    description: stringValue(value.description) ?? "",
+    ...parameters !== void 0 ? { parameters } : {},
+    propertyCount: properties ? Object.keys(properties).length : 0,
+    requiredFields,
+    sources: [source("request", path, value)]
+  };
+}
+
+// src/model-evidence/transport.ts
+var DONE_MARKER = "[DONE]";
+function parseResponseTransport(raw, format) {
+  if (raw === void 0 || raw === "") {
+    return { transport: { kind: "empty" }, payloads: [], diagnostics: [] };
+  }
+  if (format === "sse") return parseSse(raw);
+  if (format === "text") {
+    return { transport: { kind: "text", value: raw }, payloads: [{ path: [], value: raw, streaming: false }], diagnostics: [] };
+  }
+  try {
+    const value = JSON.parse(raw);
+    return { transport: { kind: "json", value }, payloads: [{ path: [], value, streaming: false }], diagnostics: [] };
+  } catch {
+    return {
+      transport: { kind: "text", value: raw },
+      payloads: [],
+      diagnostics: format === "json" ? [{ code: "response-body-malformed", severity: "error", source: source("response", [], raw) }] : []
+    };
+  }
+}
+function parseSse(raw) {
+  const events = [];
+  const payloads = [];
+  const diagnostics = [];
+  for (const block of raw.replace(/\r\n/g, "\n").split(/\n\n+/)) {
+    if (!block.trim()) continue;
+    const data = [];
+    let event = "message";
+    let id;
+    for (const line of block.split("\n")) {
+      if (line.startsWith(":")) continue;
+      const separator = line.indexOf(":");
+      const field = separator < 0 ? line : line.slice(0, separator);
+      const value = separator < 0 ? "" : line.slice(separator + 1).replace(/^ /, "");
+      if (field === "data") data.push(value);
+      else if (field === "event") event = value || "message";
+      else if (field === "id") id = value;
+    }
+    const rawData = data.join("\n");
+    if (!rawData && event === "message" && id === void 0) continue;
+    const index = events.length;
+    let parsed = rawData;
+    let malformed = false;
+    if (rawData !== DONE_MARKER) {
+      try {
+        parsed = JSON.parse(rawData);
+      } catch {
+        malformed = true;
+      }
+    }
+    events.push({ ...id !== void 0 ? { id } : {}, event, data: parsed });
+    if (rawData === DONE_MARKER) continue;
+    if (malformed) {
+      diagnostics.push({
+        code: "response-body-malformed",
+        severity: "error",
+        source: source("response", [String(index), "data"], rawData)
+      });
+      continue;
+    }
+    payloads.push({ path: [String(index), "data"], value: parsed, streaming: true });
+  }
+  return { transport: { kind: "sse", value: events }, payloads, diagnostics };
+}
+
+// src/model-evidence/usage.ts
+function normalizeUsageCandidate(usage2) {
+  if (!usage2) return void 0;
+  const cacheReadTokens = readUsageNumber(usage2, ["cache_read_input_tokens"]) ?? 0;
+  const cacheCreationTokens = readUsageNumber(usage2, ["cache_creation_input_tokens"]) ?? 0;
+  const cachedTokens = firstUsageNumber(usage2, [
+    ["prompt_tokens_details", "cached_tokens"],
+    ["input_tokens_details", "cached_tokens"],
+    ["cachedContentTokenCount"]
+  ]) ?? (cacheReadTokens + cacheCreationTokens || void 0);
+  const reasoningTokens = firstUsageNumber(usage2, [
+    ["completion_tokens_details", "reasoning_tokens"],
+    ["output_tokens_details", "reasoning_tokens"],
+    ["thoughtsTokenCount"],
+    ["reasoning_tokens"]
+  ]);
+  let inputTokens = firstUsageNumber(usage2, [
+    ["prompt_tokens"],
+    ["promptTokenCount"]
+  ]);
+  if (inputTokens === void 0) {
+    const uncachedInputTokens = readUsageNumber(usage2, ["input_tokens"]);
+    inputTokens = uncachedInputTokens === void 0 ? void 0 : uncachedInputTokens + cacheReadTokens + cacheCreationTokens;
+  }
+  let outputTokens = firstUsageNumber(usage2, [
+    ["completion_tokens"],
+    ["output_tokens"],
+    ["candidatesTokenCount"]
+  ]);
+  if (outputTokens !== void 0 && reasoningTokens !== void 0 && "completion_tokens" in usage2) {
+    outputTokens = Math.max(0, outputTokens - reasoningTokens);
+  }
+  const reportedTotal = firstUsageNumber(usage2, [
+    ["total_tokens"],
+    ["totalTokenCount"]
+  ]);
+  if ((outputTokens === void 0 || outputTokens === 0) && inputTokens !== void 0 && reportedTotal !== void 0) {
+    const impliedVisible = reportedTotal - inputTokens - (reasoningTokens ?? 0);
+    if (impliedVisible > 0) outputTokens = impliedVisible;
+  }
+  const totalTokens = reportedTotal ?? sumUsageTokens(inputTokens, outputTokens, reasoningTokens);
+  const normalized = { inputTokens, outputTokens, reasoningTokens, cachedTokens, totalTokens };
+  return Object.values(normalized).some((value) => value !== void 0) ? normalized : void 0;
+}
+function mergeUsage(current, incoming) {
+  if (!current) return { ...incoming };
+  const merged = { ...current };
+  for (const [key, value] of Object.entries(incoming)) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      const existing = merged[key];
+      merged[key] = typeof existing === "number" ? Math.max(existing, value) : value;
+      continue;
+    }
+    if (isRecord(value)) {
+      const existing = merged[key];
+      merged[key] = isRecord(existing) ? mergeUsage(existing, value) : { ...value };
+      continue;
+    }
+    if (value !== void 0) merged[key] = value;
+  }
+  return merged;
+}
+function firstUsageNumber(usage2, paths) {
+  for (const path of paths) {
+    const value = readUsageNumber(usage2, path);
+    if (value !== void 0) return value;
+  }
+}
+function readUsageNumber(usage2, path) {
+  let value = usage2;
+  for (const key of path) {
+    if (!isRecord(value)) return void 0;
+    value = value[key];
+  }
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function sumUsageTokens(...values) {
+  const available = values.filter((value) => value !== void 0);
+  return available.length ? available.reduce((total, value) => total + value, 0) : void 0;
+}
+
+// src/model-evidence/response.ts
+var ANTHROPIC_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "message",
+  "message_start",
+  "message_delta",
+  "message_stop",
+  "content_block_start",
+  "content_block_delta",
+  "content_block_stop",
+  "ping"
+]);
+var AI_SDK_PART_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "text-start",
+  "text-delta",
+  "text-end",
+  "reasoning",
+  "reasoning-start",
+  "reasoning-delta",
+  "reasoning-end",
+  "tool-input-start",
+  "tool-input-delta",
+  "tool-call",
+  "tool-result",
+  "tool-output",
+  "finish",
+  "finish-step",
+  "error"
+]);
+function projectResponseEvidence(raw, format) {
+  const { transport, payloads, diagnostics } = parseResponseTransport(raw, format);
+  const collector = createCollector();
+  for (const payload of payloads) projectPayload(payload, payload.value, payload.path, collector, diagnostics);
+  return { transport, events: collector.events(), diagnostics };
+}
+function createCollector() {
+  const order = [];
+  const byKey = /* @__PURE__ */ new Map();
+  const dedupe = /* @__PURE__ */ new Map();
+  return {
+    collect: (draft) => {
+      const key = draft.dedupeKey !== void 0 ? dedupe.get(draft.dedupeKey) ?? `${draft.kind}|${draft.slot.join(".")}` : `${draft.kind}|${draft.slot.join(".")}`;
+      if (draft.dedupeKey !== void 0 && !dedupe.has(draft.dedupeKey)) dedupe.set(draft.dedupeKey, key);
+      let event = byKey.get(key);
+      if (!event) {
+        event = { kind: draft.kind, slot: draft.slot, sources: [], sourceKeys: /* @__PURE__ */ new Set() };
+        byKey.set(key, event);
+        order.push(key);
+      }
+      const sourceKey = draft.source.path.join(".");
+      if (!event.sourceKeys.has(sourceKey)) {
+        event.sourceKeys.add(sourceKey);
+        event.sources.push(draft.source);
+      }
+      if (draft.text !== void 0) {
+        event.text = accumulate(event.text, draft.text, draft.textAccumulation ?? "snapshot");
+      }
+      if (draft.arguments !== void 0) {
+        event.arguments = accumulate(event.arguments, draft.arguments, draft.argumentsAccumulation ?? "snapshot");
+      }
+      if (draft.name && !event.name) event.name = draft.name;
+      if (draft.callId && !event.callId) event.callId = draft.callId;
+      if (draft.usage) event.usage = mergeUsage(event.usage, draft.usage);
+    },
+    events: () => order.flatMap((key) => {
+      const event = byKey.get(key);
+      if (!event) return [];
+      const normalizedUsage = event.usage ? normalizeUsageCandidate(event.usage) : void 0;
+      return [{
+        evidenceId: evidenceId("response", event.kind, event.slot),
+        kind: event.kind,
+        ...event.text !== void 0 ? { text: event.text } : {},
+        ...event.name !== void 0 ? { name: event.name } : {},
+        ...event.callId !== void 0 ? { callId: event.callId } : {},
+        ...event.arguments !== void 0 ? { arguments: event.arguments } : {},
+        ...event.usage !== void 0 ? { usage: event.usage } : {},
+        ...normalizedUsage ? { normalizedUsage } : {},
+        sources: event.sources
+      }];
+    })
+  };
+}
+function accumulate(existing, incoming, mode) {
+  if (existing === void 0) return incoming;
+  if (mode === "delta") return `${existing}${incoming}`;
+  if (incoming === existing) return existing;
+  return incoming;
+}
+function projectPayload(payload, value, path, collector, diagnostics) {
+  if (typeof value === "string") {
+    if (!value) return;
+    collector.collect({
+      kind: "content",
+      slot: ["body"],
+      text: value,
+      textAccumulation: "snapshot",
+      source: source("response", path, value)
+    });
+    return;
+  }
+  if (!isRecord(value)) {
+    unknownPayload(value, path, collector, diagnostics, "response-payload-unsupported");
+    return;
+  }
+  const context = { path, streaming: payload.streaming, collect: collector.collect };
+  const matched = ADAPTERS.filter((adapter) => adapter.matches(value));
+  if (matched.length > 1) {
+    unknownPayload(value, path, collector, diagnostics, "response-payload-ambiguous");
+    collectUsage(value, path, collector);
+    return;
+  }
+  if (matched.length === 1) {
+    matched[0].project(value, context, payload, collector, diagnostics);
+    collectUsage(value, path, collector);
+    return;
+  }
+  const usageOnly = collectUsage(value, path, collector);
+  if (!usageOnly) unknownPayload(value, path, collector, diagnostics, "response-payload-unsupported");
+}
+function unknownPayload(value, path, collector, diagnostics, code) {
+  collector.collect({ kind: "unknown", slot: ["unknown", ...path], source: source("response", path, value) });
+  diagnostics.push({ code, severity: "warning", source: source("response", path, value) });
+}
+function collectUsage(value, path, collector) {
+  let found = false;
+  for (const field of ["usage", "usageMetadata"]) {
+    const usage2 = value[field];
+    if (!isRecord(usage2)) continue;
+    found = true;
+    collector.collect({
+      kind: "usage",
+      slot: ["usage"],
+      usage: usage2,
+      source: source("response", [...path, field], usage2)
+    });
+  }
+  return found;
+}
+var openAiChatAdapter = {
+  matches: (payload) => Array.isArray(payload.choices),
+  project: (payload, context) => {
+    for (const [index, choice] of payload.choices.entries()) {
+      if (!isRecord(choice)) continue;
+      const choicePath = [...context.path, "choices", String(index)];
+      const container = isRecord(choice.message) ? { field: "message", value: choice.message, accumulation: "snapshot" } : isRecord(choice.delta) ? { field: "delta", value: choice.delta, accumulation: "delta" } : void 0;
+      if (container) {
+        const base = [...choicePath, container.field];
+        for (const field of ["reasoning_content", "reasoning", "reasoning_text"]) {
+          const text = stringValue(container.value[field]);
+          if (!text) continue;
+          context.collect({
+            kind: "reasoning",
+            slot: ["choices", String(index), "reasoning"],
+            text,
+            textAccumulation: container.accumulation,
+            source: source("response", [...base, field], container.value[field])
+          });
+        }
+        addTextValue(context, container.value.content, [...base, "content"], ["choices", String(index), "content"], "content", container.accumulation);
+        if (Array.isArray(container.value.tool_calls)) {
+          for (const [callIndex, call] of container.value.tool_calls.entries()) {
+            if (!isRecord(call)) continue;
+            const fn = isRecord(call.function) ? call.function : call;
+            const slotKey = typeof call.index === "number" ? String(call.index) : String(callIndex);
+            context.collect({
+              kind: "tool-call",
+              slot: ["choices", String(index), "tool_calls", slotKey],
+              ...readToolName(fn) ? { name: readToolName(fn) } : {},
+              ...readCallObjectId(call) ? { callId: readCallObjectId(call) } : {},
+              ...fn.arguments === void 0 ? {} : { arguments: stringifyArguments(fn.arguments), argumentsAccumulation: container.accumulation },
+              source: source("response", [...base, "tool_calls", String(callIndex)], call)
+            });
+          }
+        }
+        if (isRecord(container.value.function_call)) {
+          const call = container.value.function_call;
+          context.collect({
+            kind: "tool-call",
+            slot: ["choices", String(index), "function_call"],
+            ...readToolName(call) ? { name: readToolName(call) } : {},
+            ...call.arguments === void 0 ? {} : { arguments: stringifyArguments(call.arguments), argumentsAccumulation: container.accumulation },
+            source: source("response", [...base, "function_call"], call)
+          });
+        }
+      }
+      for (const field of ["finish_reason", "native_finish_reason"]) {
+        const finish = stringValue(choice[field]);
+        if (!finish) continue;
+        context.collect({
+          kind: "finish-reason",
+          slot: ["choices", String(index), field],
+          text: finish,
+          source: source("response", [...choicePath, field], choice[field])
+        });
+      }
+    }
+  }
+};
+var anthropicAdapter = {
+  matches: (payload) => Array.isArray(payload.content) || isRecord(payload.content_block) || isRecord(payload.delta) && typeof payload.delta.type === "string" || ANTHROPIC_EVENT_TYPES.has(String(payload.type)) || typeof payload.stop_reason === "string",
+  project: (payload, context, origin, collector, diagnostics) => {
+    if (isRecord(payload.message)) {
+      projectPayload(origin, payload.message, [...context.path, "message"], collector, diagnostics);
+    }
+    if (Array.isArray(payload.content)) {
+      for (const [index, block] of payload.content.entries()) {
+        if (!isRecord(block)) continue;
+        const blockPath = [...context.path, "content", String(index)];
+        const slot = ["content", String(index)];
+        const type = String(block.type ?? "");
+        if (type === "text") {
+          const text = stringValue(block.text);
+          if (text) context.collect({ kind: "content", slot, text, source: source("response", [...blockPath, "text"], block.text) });
+          continue;
+        }
+        if (type === "thinking") {
+          const text = stringValue(block.thinking);
+          if (text) context.collect({ kind: "reasoning", slot, text, source: source("response", [...blockPath, "thinking"], block.thinking) });
+          continue;
+        }
+        if (type === "tool_use") {
+          context.collect({
+            kind: "tool-call",
+            slot,
+            ...readToolName(block) ? { name: readToolName(block) } : {},
+            ...stringValue(block.id) ? { callId: stringValue(block.id) } : {},
+            ...block.input === void 0 ? {} : { arguments: stringifyArguments(block.input) },
+            source: source("response", blockPath, block)
+          });
+          continue;
+        }
+        if (type === "tool_result") {
+          collectToolResult(context, block, blockPath, slot, block.content);
+        }
+      }
+    }
+    if (isRecord(payload.content_block)) {
+      const blockSlot = ["content_block", typeof payload.index === "number" ? String(payload.index) : "0"];
+      const block = payload.content_block;
+      if (String(block.type ?? "") === "tool_use") {
+        context.collect({
+          kind: "tool-call",
+          slot: blockSlot,
+          ...readToolName(block) ? { name: readToolName(block) } : {},
+          ...stringValue(block.id) ? { callId: stringValue(block.id) } : {},
+          source: source("response", [...context.path, "content_block"], block)
+        });
+      }
+    }
+    if (isRecord(payload.delta)) {
+      const delta = payload.delta;
+      const blockSlot = ["content_block", typeof payload.index === "number" ? String(payload.index) : "0"];
+      const deltaPath = [...context.path, "delta"];
+      if (delta.type === "text_delta" && stringValue(delta.text)) {
+        context.collect({ kind: "content", slot: blockSlot, text: String(delta.text), textAccumulation: "delta", source: source("response", [...deltaPath, "text"], delta.text) });
+      }
+      if (delta.type === "thinking_delta" && stringValue(delta.thinking)) {
+        context.collect({ kind: "reasoning", slot: blockSlot, text: String(delta.thinking), textAccumulation: "delta", source: source("response", [...deltaPath, "thinking"], delta.thinking) });
+      }
+      if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+        context.collect({ kind: "tool-call", slot: blockSlot, arguments: delta.partial_json, argumentsAccumulation: "delta", source: source("response", [...deltaPath, "partial_json"], delta.partial_json) });
+      }
+      const stop2 = stringValue(delta.stop_reason);
+      if (stop2) context.collect({ kind: "finish-reason", slot: ["stop_reason"], text: stop2, source: source("response", [...deltaPath, "stop_reason"], delta.stop_reason) });
+    }
+    const stop = stringValue(payload.stop_reason);
+    if (stop) {
+      context.collect({ kind: "finish-reason", slot: ["stop_reason"], text: stop, source: source("response", [...context.path, "stop_reason"], payload.stop_reason) });
+    }
+  }
+};
+var geminiAdapter = {
+  matches: (payload) => Array.isArray(payload.candidates),
+  project: (payload, context) => {
+    for (const [index, candidate] of payload.candidates.entries()) {
+      if (!isRecord(candidate)) continue;
+      const candidatePath = [...context.path, "candidates", String(index)];
+      if (isRecord(candidate.content) && Array.isArray(candidate.content.parts)) {
+        for (const [partIndex, part] of candidate.content.parts.entries()) {
+          if (!isRecord(part)) continue;
+          const partPath = [...candidatePath, "content", "parts", String(partIndex)];
+          const reasoning = part.thought === true;
+          if (typeof part.text === "string" && part.text) {
+            context.collect({
+              kind: reasoning ? "reasoning" : "content",
+              slot: context.streaming ? ["candidates", String(index), reasoning ? "thought" : "content"] : ["candidates", String(index), "parts", String(partIndex)],
+              text: part.text,
+              textAccumulation: context.streaming ? "delta" : "snapshot",
+              source: source("response", [...partPath, "text"], part.text)
+            });
+          }
+          if (isRecord(part.functionCall)) {
+            const call = part.functionCall;
+            context.collect({
+              kind: "tool-call",
+              slot: ["candidates", String(index), "parts", String(partIndex)],
+              ...readToolName(call) ? { name: readToolName(call) } : {},
+              ...stringValue(call.id) ? { callId: stringValue(call.id) } : {},
+              ...call.args === void 0 ? {} : { arguments: stringifyArguments(call.args) },
+              source: source("response", [...partPath, "functionCall"], call)
+            });
+          }
+        }
+      }
+      const finish = stringValue(candidate.finishReason);
+      if (finish) {
+        context.collect({
+          kind: "finish-reason",
+          slot: ["candidates", String(index), "finishReason"],
+          text: finish,
+          source: source("response", [...candidatePath, "finishReason"], candidate.finishReason)
+        });
+      }
+    }
+  }
+};
+var responsesAdapter = {
+  matches: (payload) => Array.isArray(payload.output) || typeof payload.type === "string" && payload.type.startsWith("response."),
+  project: (payload, context, origin, collector, diagnostics) => {
+    const type = stringValue(payload.type);
+    if (type) {
+      if (type.endsWith(".output_text.delta") && stringValue(payload.delta)) {
+        context.collect({ kind: "content", slot: ["output_text"], text: String(payload.delta), textAccumulation: "delta", source: source("response", [...context.path, "delta"], payload.delta) });
+      }
+      if (type.endsWith(".reasoning_summary_text.delta") && stringValue(payload.delta)) {
+        context.collect({ kind: "reasoning", slot: ["reasoning_summary_text"], text: String(payload.delta), textAccumulation: "delta", source: source("response", [...context.path, "delta"], payload.delta) });
+      }
+      if (type.endsWith(".function_call_arguments.delta")) {
+        const itemId = stringValue(payload.item_id);
+        context.collect({
+          kind: "tool-call",
+          slot: ["item", itemId ?? "function_call"],
+          ...readToolName(payload) ? { name: readToolName(payload) } : {},
+          ...itemId ? { callId: itemId } : {},
+          ...typeof payload.delta === "string" ? { arguments: payload.delta, argumentsAccumulation: "delta" } : {},
+          source: source("response", [...context.path, "delta"], payload.delta)
+        });
+      }
+      if (isRecord(payload.response)) {
+        projectPayload(origin, payload.response, [...context.path, "response"], collector, diagnostics);
+      }
+    }
+    if (!Array.isArray(payload.output)) return;
+    for (const [index, item] of payload.output.entries()) {
+      if (!isRecord(item)) continue;
+      const itemPath = [...context.path, "output", String(index)];
+      const slot = ["output", String(index)];
+      const itemType = stringValue(item.type);
+      if (itemType === "message") {
+        addTextValue(context, item.content, itemPath, slot, "content", "snapshot");
+        continue;
+      }
+      if (itemType === "reasoning") {
+        addTextValue(context, item.summary, itemPath, slot, "reasoning", "snapshot");
+        continue;
+      }
+      if (itemType === "function_call") {
+        context.collect({
+          kind: "tool-call",
+          slot,
+          ...readToolName(item) ? { name: readToolName(item) } : {},
+          ...stringValue(item.call_id) ? { callId: stringValue(item.call_id) } : {},
+          ...item.arguments === void 0 ? {} : { arguments: stringifyArguments(item.arguments) },
+          source: source("response", itemPath, item)
+        });
+        continue;
+      }
+      if (itemType === "function_call_output") {
+        collectToolResult(context, item, itemPath, slot, item.output ?? item.result ?? item.content);
+      }
+    }
+  }
+};
+var aiSdkAdapter = {
+  matches: (payload) => typeof payload.type === "string" && AI_SDK_PART_TYPES.has(payload.type),
+  project: (payload, context) => {
+    const type = String(payload.type);
+    const id = stringValue(payload.id) ?? stringValue(payload.toolCallId) ?? "0";
+    if (type === "text" || type === "text-delta") {
+      const text = stringValue(payload.text) ?? stringValue(payload.delta);
+      if (text) {
+        context.collect({
+          kind: "content",
+          slot: ["text", id],
+          text,
+          textAccumulation: type === "text-delta" ? "delta" : "snapshot",
+          source: source("response", context.path, payload)
+        });
+      }
+      return;
+    }
+    if (type === "reasoning" || type === "reasoning-delta") {
+      const text = stringValue(payload.text) ?? stringValue(payload.delta);
+      if (text) {
+        context.collect({
+          kind: "reasoning",
+          slot: ["reasoning", id],
+          text,
+          textAccumulation: type === "reasoning-delta" ? "delta" : "snapshot",
+          source: source("response", context.path, payload)
+        });
+      }
+      return;
+    }
+    if (type === "tool-input-delta") {
+      context.collect({
+        kind: "tool-call",
+        slot: ["tool", id],
+        ...typeof payload.delta === "string" ? { arguments: payload.delta, argumentsAccumulation: "delta" } : {},
+        source: source("response", context.path, payload)
+      });
+      return;
+    }
+    if (type === "tool-input-start" || type === "tool-call") {
+      const args = payload.input ?? payload.args ?? payload.arguments;
+      context.collect({
+        kind: "tool-call",
+        slot: ["tool", id],
+        ...readToolName(payload) ? { name: readToolName(payload) } : {},
+        ...readCallId(payload) ? { callId: readCallId(payload) } : {},
+        ...args === void 0 ? {} : { arguments: stringifyArguments(args) },
+        source: source("response", context.path, payload)
+      });
+      return;
+    }
+    if (type === "tool-result" || type === "tool-output") {
+      collectToolResult(context, payload, context.path, ["tool-result", id], payload.output ?? payload.result ?? payload.content);
+      return;
+    }
+    if (type === "finish" || type === "finish-step") {
+      const reason = stringValue(payload.finishReason) ?? stringValue(payload.finish_reason);
+      if (reason) {
+        context.collect({ kind: "finish-reason", slot: ["finishReason"], text: reason, source: source("response", context.path, payload) });
+      }
+    }
+  }
+};
+var ADAPTERS = [
+  openAiChatAdapter,
+  responsesAdapter,
+  anthropicAdapter,
+  geminiAdapter,
+  aiSdkAdapter
+];
+function collectToolResult(context, raw, path, slot, output) {
+  const callId = readCallId(raw);
+  const name2 = readToolName(raw);
+  const text = normalizeToolOutput(output);
+  context.collect({
+    kind: "tool-result",
+    slot,
+    text,
+    ...name2 ? { name: name2 } : {},
+    ...callId ? { callId } : {},
+    dedupeKey: JSON.stringify(["tool-result", callId ?? "", name2 ?? "", text]),
+    source: source("response", path, raw)
+  });
+}
+function addTextValue(context, value, path, slot, kind, accumulation) {
+  if (typeof value === "string") {
+    if (value) context.collect({ kind, slot, text: value, textAccumulation: accumulation, source: source("response", path, value) });
+    return;
+  }
+  if (!Array.isArray(value)) return;
+  const text = value.flatMap((item) => {
+    if (typeof item === "string") return [item];
+    if (!isRecord(item)) return [];
+    const part = stringValue(item.text) ?? stringValue(item.output_text) ?? stringValue(item.content);
+    return part ? [part] : [];
+  }).join("");
+  if (text) context.collect({ kind, slot, text, textAccumulation: accumulation, source: source("response", path, value) });
+}
+function stringifyArguments(value) {
+  return typeof value === "string" ? value : stringifyValue(value);
+}
+
+// src/model-evidence/metrics.ts
+function countMessageCharacters(message) {
+  const text = message.text || message.contentParts.map((part) => part.value).join("\n");
+  return text.length + (message.reasoning?.length ?? 0);
+}
+function countToolCallCharacters(call) {
+  return call.arguments?.length ?? serializedLength(call.sources[0]?.value);
+}
+function countToolDefinitionCharacters(definition) {
+  return serializedLength(definition.sources[0]?.value);
+}
+function serializedLength(value) {
+  if (value === void 0 || value === null) return 0;
+  if (typeof value === "string") return value.length;
+  try {
+    return JSON.stringify(value).length;
+  } catch {
+    return String(value).length;
+  }
+}
+
+// src/model-evidence/index.ts
+function projectModelEvidence(slice) {
+  const request = projectRequestEvidence(slice.requestBody);
+  const response = projectResponseEvidence(slice.responseBodyRaw, slice.responseBodyFormat);
+  return {
+    requestMessages: request.messages,
+    toolDefinitions: request.toolDefinitions,
+    responseEvents: response.events,
+    responseTransport: response.transport,
+    diagnostics: [...request.diagnostics, ...response.diagnostics]
+  };
+}
+
+// src/model-request-variables.ts
+var import_yaml2 = require("yaml");
+
+// src/presets/evidence-match.ts
+var MAX_VARIANTS = 256;
+var MAX_LITERAL_PLACEMENTS = 256;
+function matchPresetExpressionEvidence(input) {
+  if (input.expression.kind === "control") return { status: "unsupported", reason: "control-tag" };
+  const currentExpression = input.document.expressions.find((expression) => sameExpression(expression, input.expression));
+  if (!currentExpression) return { status: "stale" };
+  const field = input.document.templateFields.find((candidate) => samePath(candidate.path, currentExpression.path));
+  const snapshotTemplate = input.snapshot.templates.find((candidate) => samePath(candidate.path, currentExpression.path));
+  if (!field || !snapshotTemplate) return { status: "unsupported", reason: "template-field" };
+  if (field.value !== snapshotTemplate.template) return { status: "stale" };
+  const fieldExpressions = input.document.expressions.filter((expression) => samePath(expression.path, currentExpression.path));
+  const expressionIndex = fieldExpressions.findIndex((expression) => sameExpression(expression, currentExpression));
+  if (expressionIndex < 0) return { status: "stale" };
+  const parsed = parseTemplate(field.value);
+  if (!parsed.nodes) return { status: "ambiguous" };
+  let ambiguous = false;
+  const matches = input.evidence.requestMessages.filter((message) => message.role === snapshotTemplate.role).flatMap((message) => {
+    const result = matchTemplateInText(parsed.nodes, expressionIndex, message.text);
+    ambiguous ||= result.ambiguous;
+    return result.ranges.map((range) => ({ evidenceId: message.evidenceId, range }));
+  });
+  if (ambiguous) return { status: "ambiguous" };
+  const unique = deduplicateMatches(matches);
+  if (!unique.length) return { status: "not-observed" };
+  return unique.length === 1 ? { status: "matched", ...unique[0] } : { status: "ambiguous" };
+}
+function matchTemplateInText(nodes, targetExpressionIndex, text) {
+  const expanded = expandNodes(nodes, text);
+  const ranges = [];
+  let ambiguous = expanded.truncated;
+  let observedWithoutTarget = false;
+  for (const parts of expanded.variants) {
+    const linear = linearize(parts);
+    const result = matchLinearTemplate(linear, targetExpressionIndex, text);
+    ranges.push(...result.ranges);
+    ambiguous ||= result.ambiguous;
+    observedWithoutTarget ||= Boolean(result.observed && !linear.expressions.includes(targetExpressionIndex));
+  }
+  const uniqueRanges = deduplicateRanges(ranges);
+  if (uniqueRanges.length && observedWithoutTarget) ambiguous = true;
+  return { ranges: uniqueRanges, ambiguous };
+}
+function matchLinearTemplate(template, targetExpressionIndex, text) {
+  const enumerated = enumerateLiteralPlacements(template.literals, text);
+  const targetPositions = template.expressions.flatMap((expressionIndex, index) => expressionIndex === targetExpressionIndex ? [index] : []);
+  const results = [];
+  let ambiguous = enumerated.truncated;
+  for (const placement of enumerated.placements) {
+    if (!targetPositions.length) continue;
+    if (targetPositions.length > 1) ambiguous = true;
+    for (const targetPosition of targetPositions) {
+      let runStart = targetPosition;
+      let runEnd = targetPosition;
+      while (runStart > 0 && template.literals[runStart] === "") runStart -= 1;
+      while (runEnd + 1 < template.expressions.length && template.literals[runEnd + 1] === "") runEnd += 1;
+      const runGapStart = placement[runStart].end;
+      const runGapEnd = placement[runEnd + 1].start;
+      const runLength = runEnd - runStart + 1;
+      if (runLength > 1 && runGapEnd > runGapStart) {
+        ambiguous = true;
+        continue;
+      }
+      results.push(runLength > 1 ? { start: runGapStart, end: runGapStart } : { start: placement[targetPosition].end, end: placement[targetPosition + 1].start });
+    }
+  }
+  return { ranges: deduplicateRanges(results), ambiguous, observed: enumerated.placements.length > 0 };
+}
+function parseTemplate(template) {
+  const lexemes = tokenizeTemplate(template);
+  let position = 0;
+  const parseSequence = (stops) => {
+    const nodes2 = [];
+    while (position < lexemes.length) {
+      const lexeme = lexemes[position];
+      if (lexeme.kind === "literal") {
+        nodes2.push(lexeme);
+        position += 1;
+        continue;
+      }
+      if (lexeme.kind === "value") {
+        nodes2.push(lexeme);
+        position += 1;
+        continue;
+      }
+      if (stops.has(lexeme.control)) return nodes2;
+      if (lexeme.control === "if") {
+        position += 1;
+        const branches = [];
+        const first = parseSequence(/* @__PURE__ */ new Set(["elseif", "else", "/if"]));
+        if (!first) return;
+        branches.push(first);
+        while (controlAt(lexemes, position) === "elseif") {
+          position += 1;
+          const branch = parseSequence(/* @__PURE__ */ new Set(["elseif", "else", "/if"]));
+          if (!branch) return;
+          branches.push(branch);
+        }
+        if (controlAt(lexemes, position) === "else") {
+          position += 1;
+          const branch = parseSequence(/* @__PURE__ */ new Set(["/if"]));
+          if (!branch) return;
+          branches.push(branch);
+        } else {
+          branches.push([]);
+        }
+        if (controlAt(lexemes, position) !== "/if") return;
+        position += 1;
+        nodes2.push({ kind: "conditional", branches });
+        continue;
+      }
+      if (lexeme.control === "for" || lexeme.control === "while" || lexeme.control === "repeat") {
+        const close = `/${lexeme.control}`;
+        position += 1;
+        const body = parseSequence(/* @__PURE__ */ new Set([close]));
+        if (!body || controlAt(lexemes, position) !== close) return;
+        position += 1;
+        nodes2.push({ kind: "loop", body });
+        continue;
+      }
+      return;
+    }
+    return nodes2;
+  };
+  const nodes = parseSequence(/* @__PURE__ */ new Set());
+  return nodes && position === lexemes.length ? { nodes } : {};
+}
+function controlAt(lexemes, position) {
+  const lexeme = lexemes[position];
+  return lexeme?.kind === "control" ? lexeme.control : void 0;
+}
+function expandNodes(nodes, text) {
+  let variants = [[]];
+  let truncated = false;
+  for (const node of nodes) {
+    const expanded = expandNode(node, text);
+    truncated ||= expanded.truncated;
+    const combined = combineVariants(variants, expanded.variants);
+    variants = combined.variants;
+    truncated ||= combined.truncated;
+  }
+  return { variants, truncated };
+}
+function expandNode(node, text) {
+  if (node.kind === "literal" || node.kind === "value") return { variants: [[node]], truncated: false };
+  if (node.kind === "conditional") {
+    const variants2 = [];
+    let truncated2 = false;
+    for (const branch of node.branches) {
+      const expanded = expandNodes(branch, text);
+      truncated2 ||= expanded.truncated;
+      for (const variant of expanded.variants) {
+        if (variants2.length >= MAX_VARIANTS) {
+          truncated2 = true;
+          break;
+        }
+        variants2.push(variant);
+      }
+    }
+    return { variants: variants2, truncated: truncated2 };
+  }
+  const body = expandNodes(node.body, text);
+  let truncated = body.truncated;
+  const minimumLiteralLength = Math.min(...body.variants.map(literalLength));
+  const unboundedEmptyBody = minimumLiteralLength === 0;
+  const maximumRepeats = unboundedEmptyBody ? 2 : Math.floor(text.length / minimumLiteralLength);
+  if (unboundedEmptyBody) truncated = true;
+  const variants = [[]];
+  let repeated = [[]];
+  for (let count = 1; count <= maximumRepeats; count += 1) {
+    const combined = combineVariants(repeated, body.variants);
+    repeated = combined.variants;
+    truncated ||= combined.truncated;
+    for (const variant of repeated) {
+      if (variants.length >= MAX_VARIANTS) {
+        truncated = true;
+        return { variants, truncated };
+      }
+      variants.push(variant);
+    }
+    if (!repeated.length) break;
+  }
+  return { variants, truncated };
+}
+function combineVariants(left, right) {
+  const variants = [];
+  let truncated = false;
+  for (const prefix of left) {
+    for (const suffix of right) {
+      if (variants.length >= MAX_VARIANTS) {
+        truncated = true;
+        return { variants, truncated };
+      }
+      variants.push([...prefix, ...suffix]);
+    }
+  }
+  return { variants, truncated };
+}
+function literalLength(parts) {
+  return parts.reduce((length, part) => length + (part.kind === "literal" ? part.value.length : 0), 0);
+}
+function linearize(parts) {
+  const literals = [""];
+  const expressions = [];
+  for (const part of parts) {
+    if (part.kind === "literal") literals[literals.length - 1] += part.value;
+    else {
+      expressions.push(part.expressionIndex);
+      literals.push("");
+    }
+  }
+  return { literals, expressions };
+}
+function enumerateLiteralPlacements(literals, text) {
+  const placements = [];
+  const placement = [];
+  let truncated = false;
+  const visit = (index, minimum) => {
+    if (truncated) return;
+    const literal = literals[index];
+    if (index === literals.length - 1 && literal === "") {
+      placement[index] = { start: text.length, end: text.length };
+      if (placements.length >= MAX_LITERAL_PLACEMENTS) truncated = true;
+      else placements.push(placement.slice());
+      return;
+    }
+    if (literal === "") {
+      const offset = index === 0 ? 0 : minimum;
+      placement[index] = { start: offset, end: offset };
+      visit(index + 1, offset);
+      return;
+    }
+    let found = text.indexOf(literal, minimum);
+    while (found >= 0 && !truncated) {
+      placement[index] = { start: found, end: found + literal.length };
+      if (index === literals.length - 1) {
+        if (placements.length >= MAX_LITERAL_PLACEMENTS) truncated = true;
+        else placements.push(placement.slice());
+      } else {
+        visit(index + 1, found + literal.length);
+      }
+      found = text.indexOf(literal, found + Math.max(1, literal.length));
+    }
+  };
+  visit(0, 0);
+  return { placements, truncated };
+}
+function tokenizeTemplate(template) {
+  const lexemes = [];
+  let literal = "";
+  let position = 0;
+  let expressionIndex = 0;
+  const flushLiteral = () => {
+    if (!literal) return;
+    lexemes.push({ kind: "literal", value: literal });
+    literal = "";
+  };
+  while (position < template.length) {
+    if (template.startsWith("{{", position)) {
+      literal += "{";
+      position += 2;
+      continue;
+    }
+    if (template.startsWith("}}", position)) {
+      literal += "}";
+      position += 2;
+      continue;
+    }
+    if (template[position] !== "{") {
+      literal += template[position];
+      position += 1;
+      continue;
+    }
+    const end = findTagEnd(template, position);
+    if (end < 0) {
+      literal += template.slice(position);
+      break;
+    }
+    flushLiteral();
+    const content = template.slice(position + 1, end).trim();
+    const control = parseControl(content);
+    lexemes.push(control ? { kind: "control", control } : { kind: "value", expressionIndex });
+    expressionIndex += 1;
+    position = end + 1;
+  }
+  flushLiteral();
+  return lexemes;
+}
+function findTagEnd(value, start) {
+  let depth = 1;
+  let quote = "";
+  for (let position = start + 1; position < value.length; position += 1) {
+    const character = value[position];
+    if (quote) {
+      if (character === "\\") position += 1;
+      else if (character === quote) quote = "";
+      continue;
+    }
+    if (character === '"' || character === "'") quote = character;
+    else if (character === "{") depth += 1;
+    else if (character === "}" && --depth === 0) return position;
+  }
+  return -1;
+}
+function parseControl(content) {
+  if (/^if(?:\s|$)/.test(content)) return "if";
+  if (/^elseif(?:\s|$)/.test(content)) return "elseif";
+  if (/^else\s*$/.test(content)) return "else";
+  if (/^for(?:\s|$)/.test(content)) return "for";
+  if (/^while(?:\s|$)/.test(content)) return "while";
+  if (/^repeat(?:\s|$)/.test(content)) return "repeat";
+  const close = content.match(/^\/(if|for|while|repeat)\s*$/)?.[1];
+  return close ? `/${close}` : void 0;
+}
+function sameExpression(left, right) {
+  return samePath(left.path, right.path) && left.range.start === right.range.start && left.range.end === right.range.end && left.content === right.content && left.occurrence === right.occurrence;
+}
+function samePath(left, right) {
+  return left.length === right.length && left.every((part, index) => part === right[index]);
+}
+function deduplicateMatches(matches) {
+  return matches.filter((match, index) => matches.findIndex((candidate) => candidate.evidenceId === match.evidenceId && candidate.range.start === match.range.start && candidate.range.end === match.range.end) === index);
+}
+function deduplicateRanges(ranges) {
+  return ranges.filter((range, index) => ranges.findIndex((candidate) => candidate.start === range.start && candidate.end === range.end) === index);
+}
+
+// src/presets/source-document.ts
+var import_yaml = require("yaml");
+var CONTROL_TAG = /^(?:if(?:\s|$)|elseif(?:\s|$)|else\s*$|for(?:\s|$)|while(?:\s|$)|repeat(?:\s|$)|\/(?:if|for|while|repeat)\s*$)/;
+function parsePresetSourceDocument(kind, source2) {
+  const yaml = (0, import_yaml.parseDocument)(source2, { keepSourceTokens: true, prettyErrors: false });
+  const diagnostics = yaml.errors.map((error) => ({
+    code: "yaml-parse-error",
+    message: error.message,
+    severity: "error",
+    range: error.pos?.length === 2 ? { start: error.pos[0], end: error.pos[1] } : void 0
+  }));
+  const locatedFields = [];
+  if (kind === "core") {
+    const prompts = yaml.get("prompts", true);
+    if ((0, import_yaml.isSeq)(prompts)) {
+      prompts.items.forEach((prompt, index) => {
+        if (!(0, import_yaml.isMap)(prompt)) return;
+        collectTemplateField(prompt.get("content", true), ["prompts", index, "content"], locatedFields, diagnostics);
+      });
+    }
+    collectTemplateField(yaml.get("format_user_prompt", true), ["format_user_prompt"], locatedFields, diagnostics);
+  } else {
+    collectTemplateField(yaml.get("system", true), ["system"], locatedFields, diagnostics);
+    collectTemplateField(yaml.get("input", true), ["input"], locatedFields, diagnostics);
+  }
+  const expressions = locatedFields.flatMap((field) => scanTemplateExpressions(field, source2));
+  const templateFields = locatedFields.map(({ path, range, value }) => ({ path, range, value }));
+  const displayName = diagnostics.some(({ code }) => code === "yaml-parse-error") ? void 0 : readDisplayName(kind, yaml);
+  return { kind, source: source2, displayName, templateFields, expressions, diagnostics };
+}
+function readDisplayName(kind, yaml) {
+  if (kind === "character") return trimmedScalarString(yaml.get("name", true));
+  const keywords = yaml.get("keywords", true);
+  return (0, import_yaml.isSeq)(keywords) ? trimmedScalarString(keywords.items[0]) : void 0;
+}
+function trimmedScalarString(node) {
+  if (!(0, import_yaml.isScalar)(node) || typeof node.value !== "string" || !node.value.trim()) return void 0;
+  return node.value;
+}
+function collectTemplateField(node, path, fields, diagnostics) {
+  if (node == null) return;
+  if (!(0, import_yaml.isScalar)(node) || typeof node.value !== "string") {
+    const range = nodeRange(node);
+    diagnostics.push({
+      code: "template-field-not-string",
+      message: `\u6A21\u677F\u5B57\u6BB5 ${formatPath(path)} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`,
+      severity: "error",
+      path,
+      range
+    });
+    return;
+  }
+  const location = locateScalar(node);
+  if (!location) {
+    diagnostics.push({
+      code: "template-field-not-string",
+      message: `\u65E0\u6CD5\u5B9A\u4F4D\u6A21\u677F\u5B57\u6BB5 ${formatPath(path)} \u7684\u6E90\u7801\u8303\u56F4`,
+      severity: "error",
+      path,
+      range: nodeRange(node)
+    });
+    return;
+  }
+  fields.push({ path, range: location.range, value: node.value, location });
+}
+function scanTemplateExpressions(field, source2) {
+  const expressions = [];
+  let position = 0;
+  let occurrence = 0;
+  while (position < field.value.length) {
+    if (field.value.startsWith("{{", position) || field.value.startsWith("}}", position)) {
+      position += 2;
+      continue;
+    }
+    if (field.value[position] !== "{") {
+      position += 1;
+      continue;
+    }
+    const end = findTemplateTagEnd(field.value, position);
+    if (end < 0) break;
+    const content = field.value.slice(position + 1, end);
+    const startOffset = field.location.offsets[position];
+    const endOffset = field.location.ends[end];
+    if (startOffset != null && endOffset != null && source2[startOffset] === "{" && source2[endOffset - 1] === "}") {
+      const range = { start: startOffset, end: endOffset };
+      const sourceText = source2.slice(range.start, range.end);
+      if (sourceText.startsWith("{") && sourceText.endsWith("}")) {
+        const kind = CONTROL_TAG.test(content.trim()) ? "control" : "value";
+        expressions.push({
+          path: field.path,
+          range,
+          content,
+          kind,
+          clickable: kind === "value",
+          occurrence
+        });
+        occurrence += 1;
+      }
+    }
+    position = end + 1;
+  }
+  return expressions;
+}
+function findTemplateTagEnd(value, start) {
+  let depth = 1;
+  let quote = "";
+  for (let position = start + 1; position < value.length; position += 1) {
+    const character = value[position];
+    if (quote) {
+      if (character === "\\") position += 1;
+      else if (character === quote) quote = "";
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === "{") {
+      depth += 1;
+    } else if (character === "}") {
+      depth -= 1;
+      if (depth === 0) return position;
+    }
+  }
+  return -1;
+}
+function locateScalar(node) {
+  const range = node.range;
+  const token = node.srcToken;
+  if (!range || !token || typeof node.value !== "string") return void 0;
+  let mapped;
+  switch (token.type) {
+    case "scalar":
+      mapped = locateFlowFolded(token.source, token.offset);
+      break;
+    case "single-quoted-scalar":
+      mapped = collapseSingleQuotedEscapes(locateFlowFolded(token.source.slice(1, -1), token.offset + 1));
+      break;
+    case "double-quoted-scalar":
+      mapped = locateDoubleQuoted(token.source, token.offset);
+      break;
+    case "block-scalar":
+      mapped = locateBlockScalar(token);
+      break;
+    default:
+      return void 0;
+  }
+  if (mapped.value !== node.value) return void 0;
+  return {
+    range: { start: range[0], end: range[1] },
+    value: mapped.value,
+    offsets: mapped.offsets,
+    ends: mapped.ends
+  };
+}
+function locateFlowFolded(source2, sourceStart) {
+  let first;
+  let line;
+  try {
+    first = new RegExp("(.*?)(?<![ \\t])[ \\t]*\\r?\\n", "sy");
+    line = new RegExp("[ \\t]*(.*?)(?:(?<![ \\t])[ \\t]*)?\\r?\\n", "sy");
+  } catch {
+    first = /(.*?)[ \t]*\r?\n/sy;
+    line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+  }
+  const builder = mappedBuilder();
+  let match = first.exec(source2);
+  if (!match) {
+    builder.appendSource(source2, sourceStart);
+    return builder.result();
+  }
+  builder.appendSource(match[1], sourceStart);
+  let separator = " ";
+  let separatorStart = match[0].length - newlineWidth(match[0]);
+  let position = first.lastIndex;
+  line.lastIndex = position;
+  while (match = line.exec(source2)) {
+    const leadingWhitespace2 = match[0].length - match[0].trimStart().length;
+    const contentStart = position + leadingWhitespace2;
+    const newlineStart = position + match[0].length - newlineWidth(match[0]);
+    if (match[1] === "") {
+      if (separator === "\n") builder.appendGenerated(separator, sourceStart + separatorStart, sourceStart + separatorStart + newlineWidthAt(source2, separatorStart));
+      else separator = "\n";
+    } else {
+      builder.appendGenerated(separator, sourceStart + separatorStart, sourceStart + separatorStart + newlineWidthAt(source2, separatorStart));
+      builder.appendSource(match[1], sourceStart + contentStart);
+      separator = " ";
+    }
+    separatorStart = newlineStart;
+    position = line.lastIndex;
+  }
+  const last = /[ \t]*(.*)/sy;
+  last.lastIndex = position;
+  match = last.exec(source2);
+  const lastText = match?.[1] ?? "";
+  const leadingWhitespace = (match?.[0].length ?? 0) - lastText.length;
+  builder.appendGenerated(separator, sourceStart + separatorStart, sourceStart + separatorStart + newlineWidthAt(source2, separatorStart));
+  builder.appendSource(lastText, sourceStart + position + leadingWhitespace);
+  return builder.result();
+}
+function collapseSingleQuotedEscapes(mapped) {
+  const builder = mappedBuilder();
+  for (let position = 0; position < mapped.value.length; position += 1) {
+    if (mapped.value[position] === "'" && mapped.value[position + 1] === "'") {
+      builder.appendMapped("'", mapped.offsets[position], mapped.ends[position + 1]);
+      position += 1;
+    } else {
+      builder.appendMapped(mapped.value[position], mapped.offsets[position], mapped.ends[position]);
+    }
+  }
+  return builder.result();
+}
+function locateDoubleQuoted(source2, sourceStart) {
+  const builder = mappedBuilder();
+  for (let position = 1; position < source2.length - 1; position += 1) {
+    const character = source2[position];
+    if (character === "\r" && source2[position + 1] === "\n") continue;
+    if (character === "\n") {
+      const folded = foldDoubleQuotedNewline(source2, position);
+      builder.appendGenerated(folded.value, sourceStart + position, sourceStart + folded.offset + 1);
+      position = folded.offset;
+      continue;
+    }
+    if (character === "\\") {
+      let next = source2[++position];
+      const escapeStart = position - 1;
+      const simple = DOUBLE_QUOTED_ESCAPES[next];
+      if (simple != null) {
+        builder.appendGenerated(simple, sourceStart + escapeStart, sourceStart + position + 1);
+      } else if (next === "\n") {
+        next = source2[position + 1];
+        while (next === " " || next === "	") next = source2[++position + 1];
+      } else if (next === "\r" && source2[position + 1] === "\n") {
+        position += 1;
+        next = source2[position + 1];
+        while (next === " " || next === "	") next = source2[++position + 1];
+      } else if (next === "x" || next === "u" || next === "U") {
+        const width = next === "x" ? 2 : next === "u" ? 4 : 8;
+        const codePoint = Number.parseInt(source2.slice(position + 1, position + 1 + width), 16);
+        const decoded = String.fromCodePoint(codePoint);
+        builder.appendGenerated(decoded, sourceStart + escapeStart, sourceStart + position + width + 1);
+        position += width;
+      } else {
+        builder.appendSource(source2.slice(escapeStart, position + 1), sourceStart + escapeStart);
+      }
+      continue;
+    }
+    if (character === " " || character === "	") {
+      const whitespaceStart = position;
+      let next = source2[position + 1];
+      while (next === " " || next === "	") next = source2[++position + 1];
+      if (next !== "\n" && !(next === "\r" && source2[position + 2] === "\n")) {
+        builder.appendSource(source2.slice(whitespaceStart, position + 1), sourceStart + whitespaceStart);
+      }
+      continue;
+    }
+    builder.appendSource(character, sourceStart + position);
+  }
+  return builder.result();
+}
+function foldDoubleQuotedNewline(source2, start) {
+  let value = "";
+  let offset = start;
+  let character = source2[offset + 1];
+  while (character === " " || character === "	" || character === "\n" || character === "\r") {
+    if (character === "\r" && source2[offset + 2] !== "\n") break;
+    if (character === "\n") value += "\n";
+    offset += 1;
+    character = source2[offset + 1];
+  }
+  return { value: value || " ", offset };
+}
+var DOUBLE_QUOTED_ESCAPES = {
+  "0": "\0",
+  a: "\x07",
+  b: "\b",
+  e: "\x1B",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	",
+  v: "\v",
+  N: "\x85",
+  _: "\xA0",
+  L: "\u2028",
+  P: "\u2029",
+  " ": " ",
+  '"': '"',
+  "/": "/",
+  "\\": "\\",
+  "	": "	"
+};
+function locateBlockScalar(token) {
+  const header = parseBlockHeader(token);
+  const contentBase = token.offset + header.length;
+  const lines = splitBlockLines(token.source);
+  let chompStart = lines.length;
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const content = lines[index].content;
+    if (content === "" || content === "\r") chompStart = index;
+    else break;
+  }
+  const builder = mappedBuilder();
+  if (chompStart === 0) {
+    if (header.chomp === "+" && lines.length > 0) {
+      builder.appendGenerated("\n".repeat(Math.max(1, lines.length - 1)), contentBase, contentBase + token.source.length);
+    }
+    return builder.result();
+  }
+  let trimIndent = token.indent + header.indent;
+  let contentStart = 0;
+  for (let index = 0; index < chompStart; index += 1) {
+    const line = lines[index];
+    if (line.content === "" || line.content === "\r") {
+      if (header.indent === 0 && line.indent.length > trimIndent) trimIndent = line.indent.length;
+    } else {
+      if (header.indent === 0) trimIndent = line.indent.length;
+      contentStart = index;
+      break;
+    }
+  }
+  for (let index = lines.length - 1; index >= chompStart; index -= 1) {
+    if (lines[index].indent.length > trimIndent) chompStart = index + 1;
+  }
+  let separator = "";
+  let separatorRange = { start: contentBase, end: contentBase };
+  let previousMoreIndented = false;
+  for (let index = 0; index < contentStart; index += 1) {
+    const line = lines[index];
+    builder.appendSource(line.indent.slice(trimIndent), contentBase + line.contentOffset - line.indent.length + trimIndent);
+    builder.appendGenerated("\n", contentBase + line.newlineStart, contentBase + line.newlineEnd);
+  }
+  for (let index = contentStart; index < chompStart; index += 1) {
+    const line = lines[index];
+    let content = line.content;
+    if (content.endsWith("\r")) content = content.slice(0, -1);
+    const retainedIndent = line.indent.slice(trimIndent);
+    const retainedOffset = contentBase + line.contentOffset - line.indent.length + trimIndent;
+    if (header.mode === "|") {
+      builder.appendGenerated(separator, separatorRange.start, separatorRange.end);
+      builder.appendSource(retainedIndent + content, retainedOffset);
+      separator = "\n";
+    } else if (line.indent.length > trimIndent || content[0] === "	") {
+      if (separator === " ") separator = "\n";
+      else if (!previousMoreIndented && separator === "\n") separator = "\n\n";
+      builder.appendGenerated(separator, separatorRange.start, separatorRange.end);
+      builder.appendSource(retainedIndent + content, retainedOffset);
+      separator = "\n";
+      previousMoreIndented = true;
+    } else if (content === "") {
+      if (separator === "\n") builder.appendGenerated("\n", separatorRange.start, separatorRange.end);
+      else separator = "\n";
+    } else {
+      builder.appendGenerated(separator, separatorRange.start, separatorRange.end);
+      builder.appendSource(content, contentBase + line.contentOffset);
+      separator = " ";
+      previousMoreIndented = false;
+    }
+    separatorRange = { start: contentBase + line.newlineStart, end: contentBase + line.newlineEnd };
+  }
+  if (header.chomp === "+") {
+    for (let index = chompStart; index < lines.length; index += 1) {
+      const line = lines[index];
+      builder.appendGenerated("\n", separatorRange.start, separatorRange.end);
+      builder.appendSource(line.indent.slice(trimIndent), contentBase + line.contentOffset - line.indent.length + trimIndent);
+      separatorRange = { start: contentBase + line.newlineStart, end: contentBase + line.newlineEnd };
+    }
+    if (!builder.value().endsWith("\n")) builder.appendGenerated("\n", separatorRange.start, separatorRange.end);
+  } else if (header.chomp !== "-") {
+    builder.appendGenerated("\n", separatorRange.start, separatorRange.end);
+  }
+  return builder.result();
+}
+function parseBlockHeader(token) {
+  const props = token.props ?? [];
+  const headerSource = props[0]?.source ?? "|";
+  let indent = 0;
+  let chomp = "";
+  for (let index = 1; index < headerSource.length; index += 1) {
+    const character = headerSource[index];
+    if (!chomp && (character === "-" || character === "+")) chomp = character;
+    else if (!indent && Number(character)) indent = Number(character);
+  }
+  return {
+    mode: headerSource[0] === ">" ? ">" : "|",
+    indent,
+    chomp,
+    length: props.reduce((length, prop) => length + prop.source.length, 0)
+  };
+}
+function splitBlockLines(source2) {
+  const lines = [];
+  let offset = 0;
+  while (offset <= source2.length) {
+    const newline = source2.indexOf("\n", offset);
+    const lineEnd = newline < 0 ? source2.length : newline;
+    const raw = source2.slice(offset, lineEnd);
+    const indent = raw.match(/^ */)?.[0] ?? "";
+    lines.push({
+      indent,
+      content: raw.slice(indent.length),
+      contentOffset: offset + indent.length,
+      newlineStart: lineEnd > offset && source2[lineEnd - 1] === "\r" ? lineEnd - 1 : lineEnd,
+      newlineEnd: newline < 0 ? lineEnd : newline + 1
+    });
+    if (newline < 0) break;
+    offset = newline + 1;
+  }
+  return lines;
+}
+function mappedBuilder() {
+  let value = "";
+  const offsets = [];
+  const ends = [];
+  return {
+    appendSource(text, start) {
+      value += text;
+      for (let index = 0; index < text.length; index += 1) {
+        offsets.push(start + index);
+        ends.push(start + index + 1);
+      }
+    },
+    appendGenerated(text, start, end) {
+      value += text;
+      for (let index = 0; index < text.length; index += 1) {
+        offsets.push(start);
+        ends.push(end);
+      }
+    },
+    appendMapped(text, start, end) {
+      value += text;
+      offsets.push(start);
+      ends.push(end);
+    },
+    value: () => value,
+    result: () => ({ value, offsets, ends })
+  };
+}
+function newlineWidth(text) {
+  return text.endsWith("\r\n") ? 2 : 1;
+}
+function newlineWidthAt(source2, position) {
+  return source2[position] === "\r" && source2[position + 1] === "\n" ? 2 : 1;
+}
+function nodeRange(node) {
+  if (!node || typeof node !== "object" || !("range" in node)) return void 0;
+  const range = node.range;
+  return range ? { start: range[0], end: range[1] } : void 0;
+}
+function formatPath(path) {
+  return path.map((part) => typeof part === "number" ? `[${part}]` : part).join(".");
+}
+
+// src/model-request-variables.ts
+function deriveModelRequestVariables(snapshots, evidence) {
+  const messages = new Map(evidence.requestMessages.map((message) => [message.evidenceId, message]));
+  return snapshots.flatMap((snapshot, snapshotIndex) => {
+    const document = documentFromRuntimeSnapshot(snapshot);
+    return document.expressions.filter((expression) => expression.kind === "value").map((expression) => {
+      const matched = matchPresetExpressionEvidence({ document, expression, snapshot, evidence });
+      const base = {
+        id: `${snapshot.kind}:${snapshotIndex}:${JSON.stringify(expression.path)}#${expression.occurrence}`,
+        name: expression.content.trim(),
+        presetKind: snapshot.kind,
+        presetName: snapshot.presetName,
+        path: expression.path,
+        occurrence: expression.occurrence
+      };
+      if (matched.status !== "matched") return { ...base, status: matched.status };
+      const message = messages.get(matched.evidenceId);
+      if (!message || matched.range.start < 0 || matched.range.end < matched.range.start || matched.range.end > message.text.length) {
+        return { ...base, status: "not-observed" };
+      }
+      return {
+        ...base,
+        status: "observed",
+        value: message.text.slice(matched.range.start, matched.range.end),
+        evidenceId: matched.evidenceId,
+        range: matched.range
+      };
+    });
+  });
+}
+function modelRequestVariableStatusLabel(status) {
+  if (status === "ambiguous") return "\u5C55\u5F00\u503C\u5B58\u5728\u6B67\u4E49";
+  if (status === "stale") return "\u9884\u8BBE\u5FEB\u7167\u5DF2\u53D8\u5316";
+  if (status === "unsupported") return "\u8868\u8FBE\u5F0F\u4E0D\u652F\u6301\u5B9A\u4F4D";
+  return "\u672A\u5728\u6A21\u578B\u8BF7\u6C42\u4E2D\u89C2\u5BDF\u5230\u5C55\u5F00\u503C";
+}
+function documentFromRuntimeSnapshot(snapshot) {
+  if (snapshot.kind === "character") {
+    const fields = Object.fromEntries(snapshot.templates.flatMap((template) => template.path[0] === "system" || template.path[0] === "input" ? [[template.path[0], template.template]] : []));
+    return parsePresetSourceDocument("character", (0, import_yaml2.stringify)(fields));
+  }
+  const prompts = [];
+  let formatUserPrompt;
+  for (const template of snapshot.templates) {
+    if (template.path[0] === "format_user_prompt") {
+      formatUserPrompt = template.template;
+      continue;
+    }
+    const index = template.path[0] === "prompts" && typeof template.path[1] === "number" ? template.path[1] : void 0;
+    if (index !== void 0) prompts[index] = { role: template.role, content: template.template };
+  }
+  return parsePresetSourceDocument("core", (0, import_yaml2.stringify)({
+    prompts: prompts.map((prompt) => prompt ?? {}),
+    ...formatUserPrompt !== void 0 ? { format_user_prompt: formatUserPrompt } : {}
+  }));
+}
+
+// src/record-store.ts
+var ScopeRowIndex = class {
+  rows = [];
+  nextSequence = 1;
+  reset(rows, persistedNextSequence) {
+    this.rows = rows.map(({ sequence, bytes }) => ({ sequence: Number(sequence), bytes: Number(bytes) || 0 })).sort((left, right) => left.sequence - right.sequence);
+    this.nextSequence = Math.max(
+      1,
+      persistedNextSequence,
+      this.rows.reduce((max, row) => Math.max(max, row.sequence + 1), 1)
+    );
+  }
+  put(sequence, bytes, nextSequence = 0) {
+    const index = this.rows.findIndex((row) => row.sequence === sequence);
+    if (index >= 0) this.rows[index] = { sequence, bytes };
+    else {
+      this.rows.push({ sequence, bytes });
+      this.rows.sort((left, right) => left.sequence - right.sequence);
+    }
+    this.nextSequence = Math.max(this.nextSequence, nextSequence, sequence + 1);
+  }
+  has(sequence) {
+    return this.rows.some((row) => row.sequence === sequence);
+  }
+  clear(nextSequence) {
+    this.rows = [];
+    this.nextSequence = Math.max(this.nextSequence, nextSequence);
+  }
+  /** 从最旧开始试算，返回需要一并删除的最大序号；索引在删除成功后才由 dropThrough 收敛。 */
+  resolveCutoff(limits) {
+    let count = this.rows.length;
+    let totalBytes = this.totalBytes();
+    let cutoff;
+    for (const row of this.rows) {
+      if (count <= limits.maxRecords && totalBytes <= limits.maxBytes) break;
+      cutoff = row.sequence;
+      totalBytes -= row.bytes;
+      count -= 1;
+    }
+    return cutoff;
+  }
+  dropThrough(cutoff) {
+    this.rows = this.rows.filter((row) => row.sequence > cutoff);
+  }
+  readNextSequence() {
+    return this.nextSequence;
+  }
+  summary() {
+    return {
+      nextSequence: this.nextSequence,
+      recordCount: this.rows.length,
+      totalBytes: this.totalBytes(),
+      ...this.rows.length ? { earliestSequence: this.rows[0].sequence } : {}
+    };
+  }
+  totalBytes() {
+    return this.rows.reduce((sum, row) => sum + row.bytes, 0);
+  }
+};
+var InMemoryRecordRows = class {
+  constructor(matches) {
+    this.matches = matches;
+  }
+  matches;
+  bodies = /* @__PURE__ */ new Map();
+  index = new ScopeRowIndex();
+  async summarize() {
+    return this.index.summary();
+  }
+  async append(record, bytes, nextSequence) {
+    this.bodies.set(record.sequence, structuredClone(record));
+    this.index.put(record.sequence, bytes, nextSequence);
+    return this.index.summary();
+  }
+  async find(recordId) {
+    for (const record of this.bodies.values()) {
+      if (record.id === recordId) return structuredClone(record);
+    }
+  }
+  async replace(record, bytes) {
+    if (this.index.has(record.sequence)) {
+      this.bodies.set(record.sequence, structuredClone(record));
+      this.index.put(record.sequence, bytes);
+    }
+    return this.index.summary();
+  }
+  async query(query) {
+    return this.select(query).map((record) => structuredClone(record));
+  }
+  /**
+   * 只读出记录的一部分。投影先在存有的行上执行，再拷贝投影结果，因此读取路径不需要的子树
+   * （模型请求的请求体与响应原文）既不会被深拷贝，也不会被交给调用方。
+   */
+  async queryProjected(query, project) {
+    return this.select(query).map((record) => structuredClone(project(record)));
+  }
+  select(query) {
+    return [...this.bodies.values()].filter((record) => this.matches(record, query)).sort((left, right) => (query.order === "asc" ? 1 : -1) * (left.sequence - right.sequence)).slice(0, Math.max(0, query.limit));
+  }
+  async reclaim(limits) {
+    const cutoff = this.index.resolveCutoff(limits);
+    if (cutoff !== void 0) {
+      for (const sequence of [...this.bodies.keys()]) {
+        if (sequence <= cutoff) this.bodies.delete(sequence);
+      }
+      this.index.dropThrough(cutoff);
+    }
+    return this.index.summary();
+  }
+  async clear(nextSequence) {
+    this.bodies.clear();
+    this.index.clear(nextSequence);
+    return this.index.summary();
+  }
+};
+var SerialWriteQueue = class {
+  constructor(ready) {
+    this.ready = ready;
+  }
+  ready;
+  queue = Promise.resolve();
+  /** 队列任务可能在等待期间继续追加（例如 append 之后的容量回收），必须等到队列稳定。 */
+  async settle() {
+    await this.ready;
+    for (let guard = 0; guard < 1e3; guard += 1) {
+      const queue = this.queue;
+      await queue;
+      if (queue === this.queue) return;
+    }
+  }
+  /** 写入失败不能变成未处理的 Promise 拒绝：证据落盘是旁路能力，不应影响调用方。 */
+  push(task) {
+    void this.run(task).catch(() => void 0);
+  }
+  run(task) {
+    const result = this.queue.then(() => this.ready).then(task);
+    this.queue = result.then(() => void 0, () => void 0);
+    return result;
+  }
+};
+
+// src/types.ts
+var StudioDomainError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StudioDomainError";
+  }
+};
+var StudioModelRequestCursorExpiredError = class extends StudioDomainError {
+  constructor(message, earliestCursor) {
+    super(message);
+    this.earliestCursor = earliestCursor;
+    this.name = "StudioModelRequestCursorExpiredError";
+  }
+  earliestCursor;
+  code = "cursor_expired";
+};
+
+// src/model-request.ts
+var DEFAULT_MODEL_REQUEST_RECORD_LIMIT = 500;
+var DEFAULT_MODEL_REQUEST_RECORD_MAX_BYTES = 50 * 1024 * 1024;
+var DEFAULT_MODEL_REQUEST_PAGE_SIZE = 50;
+var MAX_MODEL_REQUEST_PAGE_SIZE = 200;
+var MODEL_REQUEST_FACET_SCAN_LIMIT = 500;
+function toModelRequestRecordHeader(record) {
+  const { requestBody: _requestBody, responseBodyRaw: _responseBodyRaw, ...header } = record;
+  return header;
+}
+function matchesModelRequestQuery(record, query) {
+  if (query.attribution && record.attribution !== query.attribution) return false;
+  if (query.botId && record.entities.botId !== query.botId) return false;
+  if (query.conversationId && record.entities.conversationId !== query.conversationId) return false;
+  if (query.interactionId && record.interactionId !== query.interactionId) return false;
+  if (query.model && record.model !== query.model) return false;
+  if (query.errorsOnly && record.status !== "error") return false;
+  if (query.beforeSequence !== void 0) {
+    return query.order === "asc" ? record.sequence > query.beforeSequence : record.sequence < query.beforeSequence;
+  }
+  if (!query.beforeCreatedAt) return true;
+  const created = record.createdAt.localeCompare(query.beforeCreatedAt);
+  if (created !== 0) return query.order === "asc" ? created > 0 : created < 0;
+  if (!query.beforeId) return true;
+  const id = record.id.localeCompare(query.beforeId);
+  return query.order === "asc" ? id > 0 : id < 0;
+}
+var InMemoryModelRequestRecords = class extends InMemoryRecordRows {
+  constructor() {
+    super(matchesModelRequestQuery);
+  }
+  queryHeaders(query) {
+    return this.queryProjected(query, toModelRequestRecordHeader);
+  }
+};
+function estimateModelRequestRecordBytes(record) {
+  return Buffer.byteLength(JSON.stringify(record), "utf8");
+}
+function createModelRequestError(error, traceId = import_koishi2.Random.id()) {
+  const message = error instanceof Error ? error.message : String(error ?? "\u6A21\u578B\u8BF7\u6C42\u5931\u8D25");
+  const lower = message.toLowerCase();
+  const retryable = lower.includes("timeout") || lower.includes("\u8D85\u65F6") || lower.includes("rate limit") || lower.includes("econnreset");
+  return { code: retryable ? "transient_error" : "model_request_error", message, retryable, traceId };
+}
+function summarizePresetSnapshots(snapshots) {
+  if (!snapshots?.length) return;
+  return snapshots.map((snapshot) => ({
+    kind: snapshot.kind,
+    presetName: snapshot.presetName,
+    capturedAt: snapshot.capturedAt,
+    templateCount: snapshot.templates.length
+  }));
+}
+function presentModelRequestListItem(record) {
+  const {
+    requestBody: _requestBody,
+    responseBodyRaw: _responseBodyRaw,
+    presetSnapshots,
+    ...listItem
+  } = record;
+  const presetSnapshotSummaries = summarizePresetSnapshots(presetSnapshots);
+  return {
+    ...structuredClone(listItem),
+    ...presetSnapshotSummaries ? { presetSnapshotSummaries } : {}
+  };
+}
+function presentModelRequestDetail(record) {
+  const evidence = record.requestBody === void 0 ? void 0 : projectModelEvidence({ requestBody: record.requestBody });
+  return {
+    ...structuredClone(record),
+    // 字段数是原始 JSON 事实，只有请求体确实是对象时才存在；非对象请求体不暗示它有 0 个字段。
+    ...isRequestBodyObject(record.requestBody) ? { requestBodyKeyCount: Object.keys(record.requestBody).length } : {},
+    ...evidence ? {
+      evidenceCounts: {
+        requestMessageCount: evidence.requestMessages.length,
+        toolDefinitionCount: evidence.toolDefinitions.length
+      }
+    } : {},
+    variables: evidence && record.presetSnapshots?.length ? deriveModelRequestVariables(record.presetSnapshots, evidence) : []
+  };
+}
+function isRequestBodyObject(body) {
+  return Boolean(body && typeof body === "object" && !Array.isArray(body));
+}
+var StudioModelRequestStore = class {
+  nextSequence = 1;
+  summary = { nextSequence: 1, recordCount: 0, totalBytes: 0 };
+  maxRecords;
+  maxBytes;
+  persistence;
+  ready;
+  writes;
+  /** 已分配序号但尚未落盘的记录；恢复完成时按持久化高水位重新编号。 */
+  staged = [];
+  pendingUpdates = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.maxRecords = options.maxRecords ?? DEFAULT_MODEL_REQUEST_RECORD_LIMIT;
+    this.maxBytes = options.maxBytes ?? DEFAULT_MODEL_REQUEST_RECORD_MAX_BYTES;
+    this.persistence = options.persistence ?? new InMemoryModelRequestRecords();
+    this.ready = this.persistence.summarize().then((summary) => {
+      let nextSequence = Math.max(1, summary.nextSequence);
+      for (const record of this.staged) record.sequence = nextSequence++;
+      this.nextSequence = nextSequence;
+      this.summary = { ...summary, nextSequence };
+    }).catch(() => {
+      this.persistence = new InMemoryModelRequestRecords();
+    });
+    this.writes = new SerialWriteQueue(this.ready);
+  }
+  waitForReady() {
+    return this.ready;
+  }
+  async waitForPersistence() {
+    for (let guard = 0; guard < 1e3; guard += 1) {
+      await this.settle();
+      if (!this.pendingUpdates.size) return;
+      await Promise.all([...this.pendingUpdates]);
+    }
+  }
+  /**
+   * 等到已入队的写入全部提交。读取只需要这一层：pendingUpdates 里是尚未产生写入的
+   * 外部 Promise（例如仍在流式传输的响应体），读取等待它们会与写入方互相死锁。
+   */
+  settle() {
+    return this.writes.settle();
+  }
+  /** 登记会在稍后触发 update 的外部 Promise（响应体旁路采集），让收尾等待能覆盖它。 */
+  trackUpdate(task) {
+    const tracked = task.finally(() => this.pendingUpdates.delete(tracked));
+    this.pendingUpdates.add(tracked);
+  }
+  async getCapacity() {
+    await this.settle();
+    return this.readCapacity();
+  }
+  append(input) {
+    const record = {
+      id: import_koishi2.Random.id(),
+      sequence: this.nextSequence++,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: input.status,
+      durationMs: input.durationMs,
+      ...input.method ? { method: input.method } : {},
+      ...input.url ? { url: input.url } : {},
+      ...input.provider ? { provider: input.provider } : {},
+      ...input.model ? { model: input.model } : {},
+      ...input.headers ? { headers: structuredClone(input.headers) } : {},
+      attribution: input.attribution,
+      entities: structuredClone(input.entities),
+      requestBodyAvailable: input.requestBodyAvailable,
+      ...input.requestBody !== void 0 ? { requestBody: structuredClone(input.requestBody) } : {},
+      responseBodyStatus: input.responseBodyStatus ?? "unavailable",
+      ...input.responseBodyFormat ? { responseBodyFormat: input.responseBodyFormat } : {},
+      ...input.responseStatus !== void 0 ? { responseStatus: input.responseStatus } : {},
+      ...input.responseBodyRaw !== void 0 ? { responseBodyRaw: input.responseBodyRaw } : {},
+      ...input.responseBodyError ? { responseBodyError: input.responseBodyError } : {},
+      ...input.interactionId ? { interactionId: input.interactionId } : {},
+      ...input.chatlunaRequestId ? { chatlunaRequestId: input.chatlunaRequestId } : {},
+      ...input.presetSnapshots?.length ? { presetSnapshots: structuredClone(input.presetSnapshots) } : {},
+      ...input.error ? { error: structuredClone(input.error) } : {},
+      ...input.chatlunaError ? { chatlunaError: structuredClone(input.chatlunaError) } : {}
+    };
+    this.staged.push(record);
+    this.writes.push(async () => {
+      this.summary = await this.persistence.append(record, estimateModelRequestRecordBytes(record), this.nextSequence);
+      await this.reclaimOverflow();
+      const index = this.staged.indexOf(record);
+      if (index >= 0) this.staged.splice(index, 1);
+    });
+    return structuredClone(record);
+  }
+  update(recordId, input) {
+    return this.writes.run(async () => {
+      const previous = await this.persistence.find(recordId);
+      if (!previous) return;
+      const next = {
+        ...previous,
+        ...input.status ? { status: input.status } : {},
+        ...input.durationMs !== void 0 ? { durationMs: input.durationMs } : {},
+        ...input.headers ? { headers: structuredClone(input.headers) } : {},
+        ...input.responseBodyStatus ? { responseBodyStatus: input.responseBodyStatus } : {},
+        ...input.responseBodyFormat ? { responseBodyFormat: input.responseBodyFormat } : {},
+        ...input.responseStatus !== void 0 ? { responseStatus: input.responseStatus } : {},
+        ...input.responseBodyRaw !== void 0 ? { responseBodyRaw: input.responseBodyRaw } : {},
+        ...input.responseBodyError ? { responseBodyError: input.responseBodyError } : {},
+        ...input.chatlunaRequestId ? { chatlunaRequestId: input.chatlunaRequestId } : {}
+      };
+      if (input.status === "success") delete next.error;
+      else if (input.error) next.error = structuredClone(input.error);
+      if (input.chatlunaError) next.chatlunaError = structuredClone(input.chatlunaError);
+      if (input.responseBodyStatus === "complete") delete next.responseBodyError;
+      this.summary = await this.persistence.replace(next, estimateModelRequestRecordBytes(next));
+      await this.reclaimOverflow();
+      return structuredClone(next);
+    }).catch(() => void 0);
+  }
+  async getRecords(input = {}) {
+    const limit = Math.min(Math.max(Number(input.limit ?? DEFAULT_MODEL_REQUEST_PAGE_SIZE) || DEFAULT_MODEL_REQUEST_PAGE_SIZE, 1), MAX_MODEL_REQUEST_PAGE_SIZE);
+    await this.settle();
+    const earliestCursor = this.summary.earliestSequence;
+    if (input.beforeSequence !== void 0) {
+      if (!Number.isInteger(input.beforeSequence) || input.beforeSequence < 1) {
+        throw new StudioDomainError("beforeSequence \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+      }
+      if (earliestCursor !== void 0 && input.beforeSequence < earliestCursor) {
+        throw new StudioModelRequestCursorExpiredError(
+          `\u6A21\u578B\u8BF7\u6C42\u8BB0\u5F55\u6E38\u6807\u5DF2\u8FC7\u671F\uFF1A${input.beforeSequence}`,
+          earliestCursor
+        );
+      }
+    }
+    const rows = await this.persistence.queryHeaders({
+      ...this.toFilter(input),
+      order: resolveModelRequestOrder(input),
+      ...input.beforeSequence !== void 0 ? { beforeSequence: input.beforeSequence } : {},
+      ...input.beforeCreatedAt ? { beforeCreatedAt: input.beforeCreatedAt } : {},
+      ...input.beforeId ? { beforeId: input.beforeId } : {},
+      limit: limit + 1
+    });
+    const records = rows.slice(0, limit);
+    const hasMore = rows.length > records.length;
+    const last = records[records.length - 1];
+    return {
+      records: records.map((record) => presentModelRequestListItem(record)),
+      hasMore,
+      nextCursor: hasMore ? last?.sequence : void 0,
+      nextCreatedAt: hasMore ? last?.createdAt : void 0,
+      nextId: hasMore ? last?.id : void 0,
+      earliestCursor,
+      capacity: this.readCapacity()
+    };
+  }
+  async getRecord(recordId) {
+    await this.settle();
+    const record = await this.persistence.find(recordId);
+    return record ? presentModelRequestDetail(record) : void 0;
+  }
+  /**
+   * 「这条模型请求记录在不在」由本记录库判定，取不到就抛。
+   *
+   * 与 `getRecord` 并存而不是替代它：本成员服务于「调用方就是要这条记录」，`getRecord` 服务于
+   * 跨记录域遍历——遍历必须能区分「这个记录域里没有」与「这个记录域的持久化坏了」，用异常表达
+   * 未命中会让一次真实故障被当成「这里没有」静默跳过。
+   */
+  async requireRecord(recordId) {
+    const record = await this.getRecord(recordId);
+    if (!record) throw new StudioDomainError(`\u6A21\u578B\u8BF7\u6C42\u8BB0\u5F55\u4E0D\u5B58\u5728\uFF1A${recordId}`);
+    return record;
+  }
+  async getRawRecords(input = {}) {
+    const limit = Math.min(Math.max(Number(input.limit ?? MAX_MODEL_REQUEST_PAGE_SIZE) || MAX_MODEL_REQUEST_PAGE_SIZE, 1), MAX_MODEL_REQUEST_PAGE_SIZE);
+    await this.settle();
+    return this.persistence.query({
+      ...this.toFilter(input),
+      order: resolveModelRequestOrder(input),
+      limit
+    });
+  }
+  clear() {
+    return this.writes.run(async () => {
+      const cleared = this.summary.recordCount;
+      this.summary = await this.persistence.clear(this.nextSequence);
+      return cleared;
+    }).catch(() => 0);
+  }
+  /**
+   * 筛选下拉的可选值。
+   *
+   * 只扫最近一段记录头而不是全表：这是一份用于「点开筛选看看有哪些会话」的辅助清单，
+   * 而记录库的保留上限本来就会淘汰更早的记录，为它引入一条新的存储查询不划算。
+   */
+  async getFacets(limit = MODEL_REQUEST_FACET_SCAN_LIMIT) {
+    await this.settle();
+    const rows = await this.persistence.queryHeaders({ order: "desc", limit });
+    const bots = /* @__PURE__ */ new Map();
+    const conversations = /* @__PURE__ */ new Map();
+    const models = /* @__PURE__ */ new Set();
+    for (const { entities, model } of rows) {
+      if (model) models.add(model);
+      if (entities.botId && !bots.has(entities.botId)) {
+        bots.set(entities.botId, {
+          id: entities.botId,
+          ...entities.botName ? { name: entities.botName } : {},
+          ...entities.platform ? { platform: entities.platform } : {}
+        });
+      }
+      if (entities.conversationId && !conversations.has(entities.conversationId)) {
+        conversations.set(entities.conversationId, {
+          id: entities.conversationId,
+          ...entities.conversationName ? { name: entities.conversationName } : {},
+          ...entities.conversationType ? { type: entities.conversationType } : {},
+          ...entities.botId ? { botId: entities.botId } : {}
+        });
+      }
+    }
+    return {
+      bots: [...bots.values()],
+      conversations: [...conversations.values()],
+      models: [...models].sort((left, right) => left.localeCompare(right))
+    };
+  }
+  toFilter(input) {
+    return {
+      ...input.attribution ? { attribution: input.attribution } : {},
+      ...input.botId ? { botId: input.botId } : {},
+      ...input.conversationId ? { conversationId: input.conversationId } : {},
+      ...input.interactionId ? { interactionId: input.interactionId } : {},
+      ...input.model ? { model: input.model } : {},
+      ...input.errorsOnly ? { errorsOnly: true } : {}
+    };
+  }
+  readCapacity() {
+    return {
+      recordCount: this.summary.recordCount,
+      totalBytes: this.summary.totalBytes,
+      maxRecords: this.maxRecords,
+      maxBytes: this.maxBytes
+    };
+  }
+  async reclaimOverflow() {
+    if (this.summary.recordCount <= this.maxRecords && this.summary.totalBytes <= this.maxBytes) return;
+    this.summary = await this.persistence.reclaim({ maxRecords: this.maxRecords, maxBytes: this.maxBytes });
+  }
+};
+function resolveModelRequestOrder(input) {
+  return input.order === "asc" ? "asc" : "desc";
+}
+
+// src/evidence-preview-text.ts
+var SCAN_CHUNK = 4096;
+var SCAN_GROWTH = 4;
+function normalizeEvidencePreviewText(value, minLength) {
+  let scan = Math.min(value.length, Math.max(minLength * SCAN_GROWTH, SCAN_CHUNK));
+  let normalized = normalize(value, scan);
+  while (normalized.length <= minLength && scan < value.length) {
+    scan = Math.min(value.length, scan * SCAN_GROWTH);
+    normalized = normalize(value, scan);
+  }
+  return normalized;
+}
+function normalize(value, scan) {
+  return (scan >= value.length ? value : value.slice(0, scan)).replace(/\s+/g, " ").trim();
+}
+
+// src/evidence-kind.ts
+var EVIDENCE_KIND_LABELS = {
+  system: { badge: "SYSTEM", title: "System" },
+  user: { badge: "USER", title: "User" },
+  assistant: { badge: "ASSISTANT", title: "Assistant" },
+  variable: { badge: "VARIABLE", title: "Variable" },
+  "tool-definition": { badge: "TOOL DEFS", title: "Tool Defs" },
+  "tool-call": { badge: "TOOL CALL", title: "Tool Call" },
+  "tool-result": { badge: "TOOL RESULT", title: "Tool Result" },
+  response: { badge: "RESPONSE", title: "Response" }
+};
+var EVIDENCE_AGGREGATE_MEMBERS = {
+  "tool-interaction": Object.freeze(["tool-call", "tool-result"]),
+  tool: Object.freeze(["tool-definition", "tool-call", "tool-result"])
+};
+var EVIDENCE_AGGREGATE_LABELS = {
+  "tool-interaction": { badge: "TOOL I/O", title: "Tool I/O" },
+  tool: { badge: "TOOL", title: "Tool" }
+};
+var STUDIO_EVIDENCE_KINDS = Object.freeze(
+  Object.keys(EVIDENCE_KIND_LABELS)
+);
+var STUDIO_EVIDENCE_AGGREGATE_IDS = Object.freeze(
+  Object.keys(EVIDENCE_AGGREGATE_MEMBERS)
+);
+function studioEvidenceLabels(id) {
+  return isAggregateId(id) ? EVIDENCE_AGGREGATE_LABELS[id] : EVIDENCE_KIND_LABELS[id];
+}
+function studioEvidenceAggregate(id) {
+  return {
+    id,
+    members: EVIDENCE_AGGREGATE_MEMBERS[id],
+    labels: EVIDENCE_AGGREGATE_LABELS[id]
+  };
+}
+function isStudioEvidenceAggregateMember(aggregate, kind) {
+  return EVIDENCE_AGGREGATE_MEMBERS[aggregate].includes(kind);
+}
+function isAggregateId(id) {
+  return id in EVIDENCE_AGGREGATE_LABELS;
+}
+
+// src/model-request-trajectory.ts
+var CONVERSATION_RECORD_LIMIT = 200;
+var TRAJECTORY_PREVIEW_LENGTH = 180;
+var TOOL_INTERACTION_KIND = studioEvidenceAggregate("tool-interaction").id;
+async function readStudioModelRequestConversationRecords(record, store) {
+  const conversationId = record.entities.conversationId;
+  if (!store || !conversationId) return;
+  return store.getRawRecords({ conversationId, order: "asc", limit: CONVERSATION_RECORD_LIMIT });
+}
+async function buildStudioModelRequestTrajectoryFromStore(options) {
+  const conversationRecords = options.mode === "conversation" ? await readStudioModelRequestConversationRecords(options.record, options.store) : void 0;
+  return buildStudioModelRequestTrajectory({
+    record: options.record,
+    mode: options.mode,
+    ...conversationRecords ? { conversationRecords } : {}
+  });
+}
+function buildStudioModelRequestTrajectory(options) {
+  const sourceRecords = options.mode === "conversation" && options.conversationRecords ? options.conversationRecords : [options.record];
+  const records = sourceRecords.map((record) => presentModelRequestListItem(record));
+  const rows = [];
+  const promptComposition = [];
+  let index = 1;
+  for (const record of sourceRecords) {
+    const projection = projectModelEvidence({
+      requestBody: record.requestBody,
+      ...record.responseBodyStatus === "complete" && record.responseBodyRaw !== void 0 ? { responseBodyRaw: record.responseBodyRaw, responseBodyFormat: record.responseBodyFormat } : {}
+    });
+    const variables = record.requestBody !== void 0 && record.presetSnapshots?.length ? deriveModelRequestVariables(record.presetSnapshots, projection) : [];
+    rows.push({
+      id: `${record.id}:request`,
+      index: index++,
+      kind: "request",
+      preview: requestPreview(record),
+      durationMs: record.durationMs,
+      startedAt: record.createdAt,
+      requestId: record.id,
+      status: record.status
+    });
+    for (const row of projectRequestRows(projection, variables)) {
+      rows.push({
+        id: `${record.id}:${row.evidenceId}`,
+        index: index++,
+        requestId: record.id,
+        source: "request",
+        ...row
+      });
+    }
+    for (const row of projectResponseRows(projection)) {
+      rows.push({ id: `${record.id}:${row.evidenceId}`, index: index++, requestId: record.id, source: "response", ...row });
+    }
+    for (const item of projectPromptComposition(projection, variables)) {
+      promptComposition.push(options.mode === "conversation" ? { ...item, requestId: record.id } : item);
+    }
+  }
+  return {
+    mode: options.mode,
+    ...options.record.entities.conversationId ? { conversationId: options.record.entities.conversationId } : {},
+    records,
+    rows,
+    promptComposition,
+    complete: options.mode === "request" || !options.conversationRecords || sourceRecords.length < CONVERSATION_RECORD_LIMIT
+  };
+}
+function projectRequestRows(projection, variables) {
+  const rows = projection.toolDefinitions.map((definition) => ({
+    evidenceId: definition.evidenceId,
+    kind: "tool-definition",
+    preview: `\u5DE5\u5177\u5B9A\u4E49 \xB7 ${definition.name}`,
+    toolName: definition.name
+  }));
+  for (const message of projection.requestMessages) {
+    rows.push(...messageRows(message));
+  }
+  for (const variable of variables) {
+    rows.push({
+      evidenceId: `variable:${variable.id}`,
+      kind: "variable",
+      preview: `${variable.name} \xB7 ${variable.status === "observed" ? compactText(variable.value ?? "") || "\u7A7A\u503C" : modelRequestVariableStatusLabel(variable.status)}`,
+      variableId: variable.id,
+      variableName: variable.name,
+      variablePresetName: variable.presetName,
+      variableStatus: variable.status,
+      ...variable.value !== void 0 ? { variableValue: variable.value } : {}
+    });
+  }
+  return rows.sort((left, right) => requestRowOrder(left.kind) - requestRowOrder(right.kind));
+}
+function requestRowOrder(kind) {
+  if (kind === "system") return 0;
+  if (kind === "user") return 1;
+  if (kind === "variable") return 2;
+  if (kind === "assistant") return 3;
+  return 4;
+}
+function messageRows(message) {
+  const rows = [];
+  if (message.role === "tool") {
+    rows.push({
+      evidenceId: message.evidenceId,
+      kind: "tool-result",
+      preview: `${message.toolName ?? "\u5DE5\u5177\u7ED3\u679C"} \xB7 ${compactText(message.text) || "\u65E0\u8F93\u51FA"}`,
+      ...message.toolName ? { toolName: message.toolName } : {},
+      ...message.toolCallId ? { callId: message.toolCallId } : {}
+    });
+    return rows;
+  }
+  const reasoning = message.reasoning ? compactText(message.reasoning) : "";
+  const text = compactText(message.text);
+  if (text || reasoning) {
+    rows.push({
+      evidenceId: message.evidenceId,
+      kind: message.role,
+      preview: text || `\u601D\u8003 \xB7 ${reasoning}`
+    });
+  }
+  for (const call of message.toolCalls) {
+    rows.push({
+      evidenceId: call.evidenceId,
+      kind: "tool-call",
+      preview: `${call.name} \xB7 ${compactText(call.arguments ?? "") || "\u65E0\u53C2\u6570"}`,
+      toolName: call.name,
+      ...call.callId ? { callId: call.callId } : {}
+    });
+  }
+  return rows;
+}
+function projectResponseRows(projection) {
+  return projection.responseEvents.flatMap((event) => {
+    if (event.kind === "reasoning") {
+      return [{ evidenceId: event.evidenceId, kind: "assistant", preview: `\u601D\u8003 \xB7 ${compactText(event.text ?? "")}` }];
+    }
+    if (event.kind === "content") {
+      return [{ evidenceId: event.evidenceId, kind: "assistant", preview: compactText(event.text ?? "") }];
+    }
+    if (event.kind === "tool-call") {
+      return [{
+        evidenceId: event.evidenceId,
+        kind: "tool-call",
+        preview: `${event.name ?? "\u5DE5\u5177\u8C03\u7528"} \xB7 ${compactText(event.arguments ?? "") || "\u65E0\u53C2\u6570"}`,
+        ...event.name ? { toolName: event.name } : {},
+        ...event.callId ? { callId: event.callId } : {}
+      }];
+    }
+    if (event.kind === "tool-result") {
+      return [{
+        evidenceId: event.evidenceId,
+        kind: "tool-result",
+        preview: `${event.name ?? "\u5DE5\u5177\u7ED3\u679C"} \xB7 ${compactText(event.text ?? "") || "\u65E0\u8F93\u51FA"}`,
+        ...event.name ? { toolName: event.name } : {},
+        ...event.callId ? { callId: event.callId } : {}
+      }];
+    }
+    return [];
+  });
+}
+function projectPromptComposition(projection, variables) {
+  const sequence = [];
+  const variablesByEvidenceId = groupObservedVariablesByEvidenceId(variables);
+  for (const message of projection.requestMessages) {
+    const kind = message.role === "tool" ? TOOL_INTERACTION_KIND : message.role;
+    const messageCharacters = countMessageCharacters(message);
+    if (kind === "system" || kind === "user") {
+      pushMessageComposition(sequence, kind, message.evidenceId, messageCharacters, variablesByEvidenceId.get(message.evidenceId) ?? []);
+    } else {
+      push(sequence, kind, message.evidenceId, messageCharacters);
+    }
+    for (const call of message.toolCalls) {
+      push(sequence, TOOL_INTERACTION_KIND, call.evidenceId, countToolCallCharacters(call));
+    }
+  }
+  const tools = projection.toolDefinitions.map((definition) => ({
+    kind: "tool-definition",
+    evidenceId: definition.evidenceId,
+    characters: Math.max(countToolDefinitionCharacters(definition), 1)
+  }));
+  let split = 0;
+  while (split < sequence.length && (sequence[split].kind === "system" || sequence[split].kind === "user")) {
+    split += 1;
+  }
+  return [...sequence.slice(0, split), ...tools, ...sequence.slice(split)];
+}
+function groupObservedVariablesByEvidenceId(variables) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const variable of variables) {
+    if (variable.status !== "observed" || !variable.evidenceId || !variable.range) continue;
+    if (variable.range.end <= variable.range.start) continue;
+    const items = grouped.get(variable.evidenceId) ?? [];
+    items.push(variable);
+    grouped.set(variable.evidenceId, items);
+  }
+  for (const items of grouped.values()) {
+    items.sort((left, right) => left.range.start - right.range.start || left.range.end - right.range.end);
+  }
+  return grouped;
+}
+function pushMessageComposition(target, kind, evidenceId2, characters, variables) {
+  if (!variables.length || characters <= 0) {
+    push(target, kind, evidenceId2, characters);
+    return;
+  }
+  let offset = 0;
+  for (const variable of variables) {
+    const range = variable.range;
+    if (range.start < offset || range.start > characters || range.end > characters) continue;
+    push(target, kind, evidenceId2, range.start - offset);
+    target.push({
+      // 模型请求变量在组成图中统一投影到 User 轨道，和工具定义一样按变量逐段展示。
+      kind: "user",
+      evidenceId: `variable:${variable.id}`,
+      characters: range.end - range.start,
+      variableId: variable.id,
+      variableName: variable.name
+    });
+    offset = range.end;
+  }
+  push(target, kind, evidenceId2, characters - offset);
+}
+function push(target, kind, evidenceId2, count) {
+  if (count > 0) target.push({ kind, evidenceId: evidenceId2, characters: count });
+}
+function requestPreview(record) {
+  const provider = record.provider || "\u672A\u77E5\u6E20\u9053";
+  const model = record.model || "\u672A\u77E5\u6A21\u578B";
+  if (record.status === "pending") return `${provider} / ${model} \xB7 \u8FDB\u884C\u4E2D`;
+  if (record.status === "error") return `${provider} / ${model} \xB7 \u8BF7\u6C42\u5931\u8D25`;
+  return `${provider} / ${model} \xB7 ${record.durationMs} ms`;
+}
+function compactText(value) {
+  const normalized = normalizeEvidencePreviewText(value, TRAJECTORY_PREVIEW_LENGTH);
+  return normalized.length > TRAJECTORY_PREVIEW_LENGTH ? `${normalized.slice(0, 177)}\u2026` : normalized;
+}
+function statusLabel(status) {
+  if (status === "pending") return "\u8FDB\u884C\u4E2D";
+  if (status === "error") return "\u9519\u8BEF";
+  return "\u5DF2\u5B8C\u6210";
+}
+
+// src/console.ts
+function resolveConsoleEntry(workspace = process.cwd()) {
+  const installedRoot = (0, import_node_path.resolve)(workspace, "node_modules/koishi-plugin-chatluna-studio");
+  const packageRoot = (0, import_node_fs.existsSync)((0, import_node_path.resolve)(installedRoot, "package.json")) ? installedRoot : (0, import_node_path.resolve)(__dirname, "..");
+  return {
+    dev: (0, import_node_path.resolve)(packageRoot, "client/index.ts"),
+    prod: (0, import_node_path.resolve)(packageRoot, "dist")
+  };
+}
+function registerConsole(console, options) {
+  const { modelRequests, presets, appearance } = options;
+  console.addEntry(resolveConsoleEntry());
+  const getWorkspace = async () => ({
+    appearance,
+    persistence: options.getPersistenceStatus()
+  });
+  const listRecords = (input) => {
+    const { scope, ...query } = input;
+    return modelRequests.getRecords(scope === "all" ? query : { ...query, attribution: scope });
+  };
+  const readRecord4 = async (input) => {
+    const detail = await modelRequests.requireRecord(input.recordId);
+    const usage2 = await lookupChatLunaUsage(options.chatlunaUsage?.(), detail);
+    return usage2 ? { ...detail, usage: usage2 } : detail;
+  };
+  const readTrajectory = async (input) => {
+    const record = await modelRequests.requireRecord(input.recordId);
+    return buildStudioModelRequestTrajectoryFromStore({ record, mode: input.mode, store: modelRequests });
+  };
+  const clearRecords = async () => ({
+    cleared: await modelRequests.clear()
+  });
+  const registerListener = console.addListener.bind(console);
+  registerListener("chatluna-studio/workspace", getWorkspace, { authority: 4 });
+  registerListener("chatluna-studio/model-request-records", listRecords, { authority: 4 });
+  registerListener("chatluna-studio/model-request-record", readRecord4, { authority: 4 });
+  registerListener("chatluna-studio/model-request-trajectory", readTrajectory, { authority: 4 });
+  registerListener("chatluna-studio/model-request-facets", () => modelRequests.getFacets(), { authority: 4 });
+  registerListener("chatluna-studio/clear-model-request-records", clearRecords, { authority: 4 });
+  registerListener("chatluna-studio/preset-catalog", (input = {}) => presets.catalog(input.kind), { authority: 4 });
+  registerListener("chatluna-studio/preset-read", (input) => presets.read(input), { authority: 4 });
+  registerListener("chatluna-studio/preset-create", (input) => presets.create(input), { authority: 4 });
+  registerListener("chatluna-studio/preset-save", (input) => presets.save(input), { authority: 4 });
+  registerListener("chatluna-studio/preset-rename", (input) => presets.rename(input), { authority: 4 });
+  registerListener("chatluna-studio/preset-delete", (input) => presets.delete(input), { authority: 4 });
+  registerListener("chatluna-studio/preset-locate-expression", (input) => presets.locateExpression(input), { authority: 4 });
+  return (sequence) => {
+    void console.broadcast("chatluna-studio/model-request-recorded", { sequence });
+  };
+}
+
+// src/model-request-collector.ts
+var import_node_module = require("module");
+var import_node_diagnostics_channel = __toESM(require("diagnostics_channel"));
+var import_node_path2 = require("path");
+var AUTH_QUERY_PATTERN = /^(?:api[_-]?key|key|token|access[_-]?token|auth(?:orization)?|secret|password|signature)$/i;
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+function isKnownChatModelRequestUrl(url) {
+  const path = readUrlPath(url);
+  return /\/chat\/completions\/?$/i.test(path) || /\/responses\/?$/i.test(path) || /\/v1\/messages\/?$/i.test(path) || /:generateContent$/i.test(path) || /:streamGenerateContent$/i.test(path);
+}
+function sanitizeModelRequestUrl(raw) {
+  try {
+    const url = new URL(raw);
+    url.username = "";
+    url.password = "";
+    for (const key of [...url.searchParams.keys()]) {
+      if (AUTH_QUERY_PATTERN.test(key)) url.searchParams.delete(key);
+    }
+    return url.toString();
+  } catch {
+    return raw.split("?")[0] ?? raw;
+  }
+}
+function resolveChatLunaPluginClass(baseDir = process.cwd()) {
+  const runtimeRequire = (0, import_node_module.createRequire)((0, import_node_path2.resolve)(baseDir, "package.json"));
+  try {
+    const loaded = runtimeRequire("koishi-plugin-chatluna/services/chat");
+    if (typeof loaded.ChatLunaPlugin?.prototype?.fetch === "function") return loaded.ChatLunaPlugin;
+  } catch {
+  }
+}
+var pendingDispatchedRequests = [];
+var undiciRequestCollectorReferences = 0;
+var undiciRequestCollectorSubscribed = false;
+function captureDispatchedModelRequest(message) {
+  const request = message && typeof message === "object" ? Reflect.get(message, "request") : void 0;
+  if (!request) return;
+  const method = String(request.method ?? "GET").toUpperCase();
+  const rawUrl = `${String(request.origin ?? "")}${String(request.path ?? "")}`;
+  if (!rawUrl || !isKnownChatModelRequestUrl(rawUrl)) return;
+  const index = pendingDispatchedRequests.findIndex((pending2) => pending2.method === method && urlsReferToSameRequest(pending2.url, rawUrl));
+  if (index < 0) return;
+  const pending = pendingDispatchedRequests.splice(index, 1)[0];
+  const rawHeaders = message && typeof message === "object" ? Reflect.get(message, "headers") : void 0;
+  const headers = readDispatchedRequestHeaders(request, rawHeaders);
+  if (Object.keys(headers).length) pending.store.update(pending.recordId, { headers });
+}
+function subscribeUndiciRequestCollector() {
+  undiciRequestCollectorReferences += 1;
+  const channel = import_node_diagnostics_channel.default.channel("undici:client:sendHeaders");
+  if (!undiciRequestCollectorSubscribed) {
+    channel.subscribe(captureDispatchedModelRequest);
+    undiciRequestCollectorSubscribed = true;
+  }
+  return () => {
+    undiciRequestCollectorReferences -= 1;
+    if (undiciRequestCollectorReferences > 0 || !undiciRequestCollectorSubscribed) return;
+    channel.unsubscribe(captureDispatchedModelRequest);
+    undiciRequestCollectorSubscribed = false;
+    pendingDispatchedRequests.splice(0);
+  };
+}
+function inferModelResponseBodyFormat(contentType, raw) {
+  if (contentType?.toLowerCase().includes("text/event-stream") || /^(?:event|data|id|retry):/m.test(raw)) return "sse";
+  try {
+    JSON.parse(raw);
+    return "json";
+  } catch {
+    return "text";
+  }
+}
+function installModelRequestCollector(options) {
+  const plugin = options.plugin ?? resolveChatLunaPluginClass(options.baseDir);
+  if (!plugin) return () => {
+  };
+  const original = plugin.prototype.fetch;
+  if (typeof original !== "function") return () => {
+  };
+  const unsubscribeUndiciRequestCollector = subscribeUndiciRequestCollector();
+  const wrapped = async function wrappedModelRequestFetch(info, init, proxy) {
+    const request = readRequest(info, init);
+    if (!request.url || !MUTATING_METHODS.has(request.method) || !isKnownChatModelRequestUrl(request.url)) {
+      return original.call(this, info, init, proxy);
+    }
+    const resolution = options.resolveTurn();
+    if (resolution.virtualOnly) return original.call(this, info, init, proxy);
+    const body = parseJsonBody(request.body);
+    const store = options.store;
+    const turn = resolution.turn;
+    const startedAt = Date.now();
+    const configuredHeaders = readRequestHeaders(info, init);
+    const presetSnapshots = turn?.entities.botId && turn.entities.conversationId ? options.getActivePresetSnapshots?.({
+      botId: turn.entities.botId,
+      conversationId: turn.entities.conversationId
+    }) : void 0;
+    const pending = store.append({
+      status: "pending",
+      durationMs: 0,
+      method: request.method,
+      url: sanitizeModelRequestUrl(request.url),
+      ...inferProvider(request.url) ? { provider: inferProvider(request.url) } : {},
+      ...inferModel(body.value, request.url) ? { model: inferModel(body.value, request.url) } : {},
+      ...Object.keys(configuredHeaders).length ? { headers: configuredHeaders } : {},
+      attribution: turn ? "attributed" : "unattributed",
+      entities: turn?.entities ?? {},
+      ...turn ? { interactionId: turn.interactionId } : {},
+      requestBodyAvailable: body.available,
+      ...body.available ? { requestBody: body.value } : {},
+      ...presetSnapshots?.length ? { presetSnapshots } : {},
+      responseBodyStatus: "pending"
+    });
+    options.onRecordAppended?.(pending);
+    pendingDispatchedRequests.push({ method: request.method, url: request.url, recordId: pending.id, store });
+    try {
+      const response = await original.call(this, info, init, proxy);
+      const durationMs = Date.now() - startedAt;
+      const responseStatus = typeof response?.status === "number" ? response.status : void 0;
+      const capture = prepareModelResponseCapture(response);
+      if (response && typeof response === "object" && response.ok === false) {
+        store.update(pending.id, {
+          status: "error",
+          durationMs,
+          responseBodyStatus: capture ? "pending" : "unavailable",
+          ...responseStatus !== void 0 ? { responseStatus } : {},
+          error: createModelRequestError(new Error(`HTTP ${response.status ?? "error"}`))
+        });
+      } else {
+        store.update(pending.id, {
+          status: "success",
+          durationMs,
+          responseBodyStatus: capture ? "pending" : "unavailable",
+          ...responseStatus !== void 0 ? { responseStatus } : {}
+        });
+      }
+      if (capture) {
+        store.trackUpdate(capture.then(({ raw, format }) => {
+          store.update(pending.id, {
+            durationMs: Date.now() - startedAt,
+            responseBodyStatus: "complete",
+            responseBodyFormat: format,
+            responseBodyRaw: raw
+          });
+        }).catch((error) => {
+          store.update(pending.id, {
+            durationMs: Date.now() - startedAt,
+            responseBodyStatus: "error",
+            responseBodyError: error instanceof Error ? error.message : String(error)
+          });
+        }));
+      }
+      return response;
+    } catch (error) {
+      store.update(pending.id, {
+        status: "error",
+        durationMs: Date.now() - startedAt,
+        responseBodyStatus: "unavailable",
+        error: createModelRequestError(error)
+      });
+      throw error;
+    }
+  };
+  plugin.prototype.fetch = wrapped;
+  return () => {
+    if (plugin.prototype.fetch === wrapped) plugin.prototype.fetch = original;
+    unsubscribeUndiciRequestCollector();
+  };
+}
+function prepareModelResponseCapture(response) {
+  if (!response || typeof response.clone !== "function" || response.bodyUsed) return;
+  try {
+    const clone = response.clone();
+    if (typeof clone.text !== "function") return;
+    const contentType = clone.headers?.get?.("content-type") ?? response.headers?.get?.("content-type") ?? void 0;
+    return clone.text().then((raw) => ({
+      raw,
+      format: inferModelResponseBodyFormat(contentType ?? void 0, raw)
+    }));
+  } catch {
+    return;
+  }
+}
+function readUrlPath(raw) {
+  try {
+    return new URL(raw).pathname;
+  } catch {
+    return raw.split("?")[0] ?? raw;
+  }
+}
+function readRequest(info, init) {
+  const url = typeof info === "string" ? info : info instanceof URL ? info.toString() : info && typeof info === "object" && typeof Reflect.get(info, "url") === "string" ? String(Reflect.get(info, "url")) : "";
+  const method = String(
+    init?.method ?? (info && typeof info === "object" ? Reflect.get(info, "method") : void 0) ?? "GET"
+  ).toUpperCase();
+  const body = init?.body ?? (info && typeof info === "object" && typeof Reflect.get(info, "body") === "string" ? Reflect.get(info, "body") : void 0);
+  return { url, method, body };
+}
+function readRequestHeaders(info, init) {
+  const source2 = init?.headers ?? (info && typeof info === "object" ? Reflect.get(info, "headers") : void 0);
+  if (!source2) return {};
+  const result = {};
+  if (typeof Headers !== "undefined" && source2 instanceof Headers) {
+    source2.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  if (Array.isArray(source2)) {
+    for (const entry of source2) {
+      if (Array.isArray(entry) && entry.length >= 2) result[String(entry[0])] = String(entry[1]);
+    }
+    return result;
+  }
+  if (typeof source2 === "object") {
+    for (const [key, value] of Object.entries(source2)) {
+      if (value !== void 0) result[key] = Array.isArray(value) ? value.join(", ") : String(value);
+    }
+  }
+  return result;
+}
+function readDispatchedRequestHeaders(request, rawHeaders) {
+  const result = typeof rawHeaders === "string" ? parseRawHttpRequestHeaders(rawHeaders) : {};
+  if (!Object.keys(result).length && Array.isArray(request.headers)) {
+    for (let index = 0; index + 1 < request.headers.length; index += 2) {
+      result[String(request.headers[index])] = String(request.headers[index + 1]);
+    }
+  }
+  if (typeof request.contentLength === "number" && request.contentLength >= 0 && !hasHeader(result, "content-length")) {
+    result["Content-Length"] = String(request.contentLength);
+  }
+  return result;
+}
+function parseRawHttpRequestHeaders(raw) {
+  const result = {};
+  for (const line of raw.split("\r\n").slice(1)) {
+    const separator = line.indexOf(":");
+    if (separator <= 0) continue;
+    const key = line.slice(0, separator).trim();
+    const value = line.slice(separator + 1).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+function hasHeader(headers, expected) {
+  return Object.keys(headers).some((key) => key.toLowerCase() === expected);
+}
+function urlsReferToSameRequest(left, right) {
+  try {
+    const leftUrl = new URL(left);
+    const rightUrl = new URL(right);
+    return leftUrl.origin === rightUrl.origin && leftUrl.pathname === rightUrl.pathname && leftUrl.search === rightUrl.search;
+  } catch {
+    return left === right;
+  }
+}
+function parseJsonBody(body) {
+  if (body == null) return { available: false };
+  let text;
+  if (typeof body === "string") text = body;
+  else if (typeof Buffer !== "undefined" && Buffer.isBuffer(body)) text = body.toString("utf8");
+  else if (body instanceof Uint8Array) text = Buffer.from(body).toString("utf8");
+  else if (body instanceof ArrayBuffer) text = Buffer.from(body).toString("utf8");
+  else return { available: false };
+  try {
+    return { available: true, value: JSON.parse(text) };
+  } catch {
+    return { available: false };
+  }
+}
+function inferModel(body, rawUrl) {
+  if (body && typeof body === "object") {
+    const directModel = Reflect.get(body, "model");
+    if (typeof directModel === "string" && directModel) return directModel;
+    const modelVersion = Reflect.get(body, "modelVersion");
+    if (typeof modelVersion === "string" && modelVersion) return modelVersion;
+  }
+  if (rawUrl) {
+    try {
+      const match = new URL(rawUrl).pathname.match(/\/models\/([^/:]+)(?::|$)/i);
+      if (match?.[1]) return decodeURIComponent(match[1]);
+    } catch {
+    }
+  }
+}
+function inferProvider(url) {
+  try {
+    const host = new URL(url).hostname.toLowerCase();
+    if (host.includes("openai")) return "openai";
+    if (host.includes("anthropic")) return "anthropic";
+    if (host.includes("googleapis") || host.includes("generativelanguage")) return "gemini";
+    if (host.includes("openrouter")) return "openrouter";
+    return host || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/persistence.ts
+var MODEL_REQUEST_RECORD_TABLE = "chatluna-studio.model-request";
+var MODEL_REQUEST_STATE_TABLE = "chatluna-studio.model-request-state";
+var MODEL_REQUEST_STATE_ID = "main";
+var DATABASE_READY_TIMEOUT_MS = 1e4;
+async function waitForDatabase(resolveDatabase, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let database = resolveDatabase();
+  while (!database && Date.now() < deadline) {
+    await new Promise((resolve5) => setTimeout(resolve5, Math.min(25, Math.max(1, deadline - Date.now()))));
+    database = resolveDatabase();
+  }
+  return database;
+}
+function registerStudioModelRequestModel(ctx) {
+  ctx.model.extend(MODEL_REQUEST_RECORD_TABLE, {
+    sequence: "unsigned",
+    id: "string(64)",
+    createdAt: "string(64)",
+    attribution: "string(16)",
+    botId: "string(64)",
+    conversationId: "string(255)",
+    interactionId: "string(64)",
+    model: "string(255)",
+    status: "string(32)",
+    bytes: "unsigned",
+    header: "json",
+    bodies: "json"
+  }, { primary: "sequence" });
+  ctx.model.extend(MODEL_REQUEST_STATE_TABLE, {
+    id: "string(32)",
+    nextSequence: "unsigned",
+    updatedAt: "timestamp"
+  }, { primary: "id" });
+}
+function sequenceCursorCondition(order, beforeSequence) {
+  return order === "asc" ? { $gt: beforeSequence } : { $lt: beforeSequence };
+}
+function fromModelRequestRow(row) {
+  return structuredClone({ ...row.header, ...row.bodies ?? {} });
+}
+function isReadableModelRequestRow(row) {
+  return Boolean(row.header && typeof row.header === "object" && typeof row.header.id === "string");
+}
+var KoishiDatabaseModelRequestPersistence = class {
+  constructor(getDatabase, readyTimeoutMs = DATABASE_READY_TIMEOUT_MS) {
+    this.getDatabase = getDatabase;
+    this.readyTimeoutMs = readyTimeoutMs;
+  }
+  getDatabase;
+  readyTimeoutMs;
+  index = new ScopeRowIndex();
+  async summarize() {
+    const database = await waitForDatabase(this.getDatabase, this.readyTimeoutMs);
+    if (!database) throw new Error(`\u7B49\u5F85 Koishi Database \u670D\u52A1 ${this.readyTimeoutMs}ms \u540E\u4ECD\u4E0D\u53EF\u7528`);
+    const [state] = await database.get(MODEL_REQUEST_STATE_TABLE, { id: MODEL_REQUEST_STATE_ID });
+    const rows = await database.get(MODEL_REQUEST_RECORD_TABLE, {}, {
+      fields: ["sequence", "bytes"],
+      sort: { sequence: "asc" }
+    });
+    this.index.reset(rows, Number(state?.nextSequence) || 1);
+    return this.index.summary();
+  }
+  async append(record, bytes, nextSequence) {
+    const database = this.requireDatabase();
+    await database.upsert(MODEL_REQUEST_RECORD_TABLE, [this.toRow(record, bytes)]);
+    this.index.put(record.sequence, bytes, nextSequence);
+    await this.saveState(database);
+    return this.index.summary();
+  }
+  async find(recordId) {
+    const database = this.requireDatabase();
+    const [row] = await database.get(MODEL_REQUEST_RECORD_TABLE, { id: recordId }, { limit: 1 });
+    return row && isReadableModelRequestRow(row) ? fromModelRequestRow(row) : void 0;
+  }
+  async replace(record, bytes) {
+    const database = this.requireDatabase();
+    if (this.index.has(record.sequence)) {
+      await database.upsert(MODEL_REQUEST_RECORD_TABLE, [this.toRow(record, bytes)]);
+      this.index.put(record.sequence, bytes);
+    }
+    return this.index.summary();
+  }
+  async query(query) {
+    const database = this.requireDatabase();
+    const rows = await database.get(MODEL_REQUEST_RECORD_TABLE, this.toRowQuery(query), {
+      sort: { sequence: query.order },
+      limit: Math.max(0, query.limit)
+    });
+    return rows.filter(isReadableModelRequestRow).map((row) => fromModelRequestRow(row));
+  }
+  async queryHeaders(query) {
+    const database = this.requireDatabase();
+    const rows = await database.get(MODEL_REQUEST_RECORD_TABLE, this.toRowQuery(query), {
+      fields: ["sequence", "header"],
+      sort: { sequence: query.order },
+      limit: Math.max(0, query.limit)
+    });
+    return rows.filter(isReadableModelRequestRow).map((row) => structuredClone(row.header));
+  }
+  async reclaim(limits) {
+    const database = this.requireDatabase();
+    const cutoff = this.index.resolveCutoff(limits);
+    if (cutoff !== void 0) {
+      await database.remove(MODEL_REQUEST_RECORD_TABLE, { sequence: { $lte: cutoff } });
+      this.index.dropThrough(cutoff);
+    }
+    return this.index.summary();
+  }
+  async clear(nextSequence) {
+    const database = this.requireDatabase();
+    await database.remove(MODEL_REQUEST_RECORD_TABLE, {});
+    this.index.clear(nextSequence);
+    await this.saveState(database);
+    return this.index.summary();
+  }
+  toRow(record, bytes) {
+    return {
+      sequence: record.sequence,
+      id: record.id,
+      createdAt: record.createdAt,
+      attribution: record.attribution,
+      // 缺省值写空串而不是 undefined：Minato 会丢弃 undefined 字段，过滤条件也就无法判定"未设置"。
+      botId: record.entities.botId ?? "",
+      conversationId: record.entities.conversationId ?? "",
+      interactionId: record.interactionId ?? "",
+      model: record.model ?? "",
+      status: record.status,
+      bytes,
+      header: structuredClone(toModelRequestRecordHeader(record)),
+      bodies: structuredClone({
+        ...record.requestBody !== void 0 ? { requestBody: record.requestBody } : {},
+        ...record.responseBodyRaw !== void 0 ? { responseBodyRaw: record.responseBodyRaw } : {}
+      })
+    };
+  }
+  toRowQuery(query) {
+    const rowQuery = {};
+    if (query.attribution) rowQuery.attribution = query.attribution;
+    if (query.botId) rowQuery.botId = query.botId;
+    if (query.conversationId) rowQuery.conversationId = query.conversationId;
+    if (query.interactionId) rowQuery.interactionId = query.interactionId;
+    if (query.model) rowQuery.model = query.model;
+    if (query.errorsOnly) rowQuery.status = "error";
+    if (query.beforeSequence !== void 0) {
+      rowQuery.sequence = sequenceCursorCondition(query.order, query.beforeSequence);
+    } else if (query.beforeCreatedAt) {
+      const strict = query.order === "asc" ? { $gt: query.beforeCreatedAt } : { $lt: query.beforeCreatedAt };
+      if (query.beforeId) {
+        rowQuery.$or = [
+          { createdAt: strict },
+          { createdAt: query.beforeCreatedAt, id: query.order === "asc" ? { $gt: query.beforeId } : { $lt: query.beforeId } }
+        ];
+      } else {
+        rowQuery.createdAt = query.order === "asc" ? { $gte: query.beforeCreatedAt } : { $lte: query.beforeCreatedAt };
+      }
+    }
+    return rowQuery;
+  }
+  async saveState(database) {
+    await database.upsert(MODEL_REQUEST_STATE_TABLE, [{
+      id: MODEL_REQUEST_STATE_ID,
+      nextSequence: this.index.readNextSequence(),
+      updatedAt: /* @__PURE__ */ new Date()
+    }]);
+  }
+  requireDatabase() {
+    const database = this.getDatabase();
+    if (!database) throw new Error("Koishi Database \u670D\u52A1\u4E0D\u53EF\u7528\uFF0C\u6A21\u578B\u8BF7\u6C42\u8BB0\u5F55\u672A\u80FD\u843D\u76D8");
+    return database;
+  }
+};
+
+// src/presets/repository.ts
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_node_path3 = require("path");
+var PresetRepositoryError = class extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+  }
+  code;
+  cause;
+  name = "PresetRepositoryError";
+};
+var mutationQueues = /* @__PURE__ */ new Map();
+var FileSystemPresetRepository = class {
+  constructor(roots, options = {}) {
+    this.options = options;
+    this.rootPaths = {
+      core: (0, import_node_path3.resolve)(roots.coreRoot),
+      character: (0, import_node_path3.resolve)(roots.characterRoot)
+    };
+  }
+  options;
+  rootPaths;
+  roots;
+  async readAll(kind) {
+    const root = await this.requireRoot(kind);
+    const entries = await (0, import_promises.readdir)(root.realPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+      if (!entry.name.endsWith(".yml") || !entry.isFile()) continue;
+      try {
+        files.push(await this.readPresetFile(root, kind, entry.name));
+      } catch (error) {
+        if (error instanceof PresetRepositoryError && error.code === "unsafe-file") continue;
+        throw error;
+      }
+    }
+    return files.sort((left, right) => left.fileName.localeCompare(right.fileName));
+  }
+  async read(kind, fileName) {
+    return this.readPresetFile(await this.requireRoot(kind), kind, fileName);
+  }
+  async create(input) {
+    const root = await this.requireRoot(input.kind);
+    const path = this.filePath(root, input.fileName);
+    return withMutationLocks([path], async () => {
+      await this.assertDestinationMissing(path);
+      await this.atomicWrite(path, input.source, true, async () => {
+        await this.beforeMutationCommit("create", void 0, path);
+        await this.revalidateRoot(root);
+        await this.assertDestinationMissing(path);
+      });
+      const snapshot = await this.readRegularFileSnapshot(path);
+      return this.toPresetFile(input.kind, input.fileName, snapshot.source, snapshot.modifiedAt);
+    });
+  }
+  async save(input) {
+    const root = await this.requireRoot(input.kind);
+    const path = this.filePath(root, input.fileName);
+    return withMutationLocks([path], async () => {
+      const original = await this.readRegularFileAfterRevision(path, input.expectedRevision);
+      if (original.revision === revisionOf(input.source)) {
+        return this.toPresetFile(input.kind, input.fileName, original.source, original.modifiedAt);
+      }
+      await this.atomicWrite(path, input.source, false, async () => {
+        await this.beforeMutationCommit("save", path, path);
+        await this.revalidateRoot(root);
+        await this.revalidateSnapshot(path, original, input.expectedRevision);
+      });
+      const saved = await this.readRegularFileSnapshot(path);
+      return this.toPresetFile(input.kind, input.fileName, saved.source, saved.modifiedAt);
+    });
+  }
+  async rename(input) {
+    this.requireConfirmation(input.confirmed);
+    const root = await this.requireRoot(input.kind);
+    const sourcePath = this.filePath(root, input.fileName);
+    const destinationPath = this.filePath(root, input.newFileName);
+    if (sourcePath === destinationPath) {
+      return withMutationLocks([sourcePath], async () => {
+        const snapshot = await this.readRegularFileAfterRevision(sourcePath, input.expectedRevision);
+        return this.toPresetFile(input.kind, input.fileName, snapshot.source, snapshot.modifiedAt);
+      });
+    }
+    return withMutationLocks([sourcePath, destinationPath], async () => {
+      const original = await this.readRegularFileAfterRevision(sourcePath, input.expectedRevision);
+      await this.assertDestinationMissing(destinationPath);
+      await this.beforeMutationCommit("rename", sourcePath, destinationPath);
+      await this.revalidateRoot(root);
+      await this.revalidateSnapshot(sourcePath, original, input.expectedRevision);
+      await this.assertDestinationMissing(destinationPath);
+      let destinationIdentity;
+      try {
+        await (0, import_promises.link)(sourcePath, destinationPath);
+        const destination = await this.readRegularFileSnapshot(destinationPath);
+        destinationIdentity = destination.identity;
+        this.assertSameSnapshot(destinationPath, destination, original, input.expectedRevision);
+        await this.revalidateSnapshot(sourcePath, original, input.expectedRevision);
+        await (0, import_promises.unlink)(sourcePath);
+      } catch (error) {
+        if (destinationIdentity) await removeIfIdentity(destinationPath, destinationIdentity);
+        throw normalizeFileSystemError(error, input.fileName);
+      }
+      const renamed = await this.readRegularFileSnapshot(destinationPath);
+      return this.toPresetFile(input.kind, input.newFileName, renamed.source, renamed.modifiedAt);
+    });
+  }
+  async delete(input) {
+    this.requireConfirmation(input.confirmed);
+    const root = await this.requireRoot(input.kind);
+    const path = this.filePath(root, input.fileName);
+    await withMutationLocks([path], async () => {
+      const original = await this.readRegularFileAfterRevision(path, input.expectedRevision);
+      await this.beforeMutationCommit("delete", path);
+      await this.revalidateRoot(root);
+      await this.revalidateSnapshot(path, original, input.expectedRevision);
+      try {
+        await (0, import_promises.unlink)(path);
+      } catch (error) {
+        throw normalizeFileSystemError(error, input.fileName);
+      }
+    });
+  }
+  async initializeRoots() {
+    const core = await this.initializeRoot(this.rootPaths.core);
+    const character = await this.initializeRoot(this.rootPaths.character);
+    return { core, character };
+  }
+  async initializeRoot(configuredPath) {
+    await (0, import_promises.mkdir)(configuredPath, { recursive: true });
+    const stats = await (0, import_promises.lstat)(configuredPath);
+    if (!stats.isDirectory() || stats.isSymbolicLink()) throw new PresetRepositoryError("unsafe-root", `\u9884\u8BBE\u6839\u76EE\u5F55\u4E0D\u5B89\u5168\uFF1A${configuredPath}`);
+    return { configuredPath, realPath: await (0, import_promises.realpath)(configuredPath) };
+  }
+  async requireRoot(kind) {
+    const roots = await (this.roots ??= this.initializeRoots());
+    const root = roots[kind];
+    await this.revalidateRoot(root);
+    return root;
+  }
+  async revalidateRoot(root) {
+    let stats;
+    let currentRealPath;
+    try {
+      stats = await (0, import_promises.lstat)(root.configuredPath);
+      currentRealPath = await (0, import_promises.realpath)(root.configuredPath);
+    } catch (error) {
+      throw new PresetRepositoryError("unsafe-root", `\u9884\u8BBE\u6839\u76EE\u5F55\u4E0D\u53EF\u7528\uFF1A${root.configuredPath}`, error);
+    }
+    if (!stats.isDirectory() || stats.isSymbolicLink() || currentRealPath !== root.realPath) {
+      throw new PresetRepositoryError("unsafe-root", `\u9884\u8BBE\u6839\u76EE\u5F55\u5DF2\u88AB\u66FF\u6362\uFF1A${root.configuredPath}`);
+    }
+  }
+  filePath(root, fileName) {
+    validateFileName(fileName);
+    const path = (0, import_node_path3.join)(root.realPath, fileName);
+    if ((0, import_node_path3.dirname)(path) !== root.realPath) throw new PresetRepositoryError("invalid-file-name", `\u65E0\u6548\u9884\u8BBE\u6587\u4EF6\u540D\uFF1A${fileName}`);
+    return path;
+  }
+  async readPresetFile(root, kind, fileName) {
+    const snapshot = await this.readRegularFileSnapshot(this.filePath(root, fileName));
+    return this.toPresetFile(kind, fileName, snapshot.source, snapshot.modifiedAt);
+  }
+  async readRegularFileSnapshot(path) {
+    let handle;
+    try {
+      const before = await (0, import_promises.lstat)(path, { bigint: true });
+      if (before.isSymbolicLink() || !before.isFile()) throw new PresetRepositoryError("unsafe-file", `\u9884\u8BBE\u4E0D\u662F\u666E\u901A\u6587\u4EF6\uFF1A${(0, import_node_path3.basename)(path)}`);
+      handle = await (0, import_promises.open)(path, import_promises.constants.O_RDONLY | noFollowFlag());
+      const opened = await handle.stat({ bigint: true });
+      if (!opened.isFile()) throw new PresetRepositoryError("unsafe-file", `\u9884\u8BBE\u4E0D\u662F\u666E\u901A\u6587\u4EF6\uFF1A${(0, import_node_path3.basename)(path)}`);
+      const identity = identityOf(opened);
+      if (!sameIdentity(identityOf(before), identity)) throw this.fileReplaced(path);
+      const source2 = await handle.readFile({ encoding: "utf8" });
+      const after = await (0, import_promises.lstat)(path, { bigint: true });
+      if (after.isSymbolicLink() || !after.isFile() || !sameIdentity(identityOf(after), identity)) throw this.fileReplaced(path);
+      return {
+        source: source2,
+        revision: revisionOf(source2),
+        identity,
+        modifiedAt: new Date(Number(opened.mtimeMs)).toISOString()
+      };
+    } catch (error) {
+      throw normalizeFileSystemError(error, (0, import_node_path3.basename)(path));
+    } finally {
+      await handle?.close().catch(() => void 0);
+    }
+  }
+  async readRegularFileAfterRevision(path, expectedRevision) {
+    const snapshot = await this.readRegularFileSnapshot(path);
+    if (snapshot.revision !== expectedRevision) throw this.revisionConflict((0, import_node_path3.basename)(path));
+    return snapshot;
+  }
+  async revalidateSnapshot(path, original, expectedRevision) {
+    const current = await this.readRegularFileSnapshot(path);
+    this.assertSameSnapshot(path, current, original, expectedRevision);
+  }
+  assertSameSnapshot(path, current, original, expectedRevision) {
+    if (!sameIdentity(current.identity, original.identity)) throw this.fileReplaced(path);
+    if (current.revision !== expectedRevision) throw this.revisionConflict((0, import_node_path3.basename)(path));
+  }
+  async assertDestinationMissing(path) {
+    try {
+      await (0, import_promises.lstat)(path);
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw normalizeFileSystemError(error, (0, import_node_path3.basename)(path));
+    }
+    throw new PresetRepositoryError("already-exists", `\u9884\u8BBE\u5DF2\u5B58\u5728\uFF1A${(0, import_node_path3.basename)(path)}`);
+  }
+  async atomicWrite(path, source2, createOnly, beforeCommit) {
+    const temporaryPath = (0, import_node_path3.join)((0, import_node_path3.dirname)(path), `.${(0, import_node_path3.basename)(path)}.${process.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`);
+    let handle;
+    try {
+      handle = await (0, import_promises.open)(temporaryPath, import_promises.constants.O_WRONLY | import_promises.constants.O_CREAT | import_promises.constants.O_EXCL | noFollowFlag(), 384);
+      await handle.writeFile(source2, "utf8");
+      await handle.sync();
+      await handle.close();
+      handle = void 0;
+      await beforeCommit();
+      if (createOnly) {
+        await (0, import_promises.link)(temporaryPath, path);
+        await (0, import_promises.unlink)(temporaryPath);
+      } else {
+        await (0, import_promises.rename)(temporaryPath, path);
+      }
+    } catch (error) {
+      throw normalizeFileSystemError(error, (0, import_node_path3.basename)(path));
+    } finally {
+      await handle?.close().catch(() => void 0);
+      await (0, import_promises.rm)(temporaryPath, { force: true }).catch(() => void 0);
+    }
+  }
+  async beforeMutationCommit(operation, sourcePath, destinationPath) {
+    await this.options.beforeMutationCommit?.({ operation, sourcePath, destinationPath });
+  }
+  toPresetFile(kind, fileName, source2, modifiedAt) {
+    return {
+      kind,
+      fileName,
+      source: source2,
+      revision: revisionOf(source2),
+      size: Buffer.byteLength(source2),
+      modifiedAt,
+      document: parsePresetSourceDocument(kind, source2)
+    };
+  }
+  requireConfirmation(confirmed) {
+    if (!confirmed) throw new PresetRepositoryError("confirmation-required", "\u91CD\u547D\u540D\u6216\u5220\u9664\u9884\u8BBE\u9700\u8981\u663E\u5F0F\u786E\u8BA4");
+  }
+  revisionConflict(fileName) {
+    return new PresetRepositoryError("revision-conflict", `\u9884\u8BBE\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u4FEE\u6539\uFF1A${fileName}`);
+  }
+  fileReplaced(path) {
+    return new PresetRepositoryError("unsafe-file", `\u9884\u8BBE\u6587\u4EF6\u5DF2\u88AB\u66FF\u6362\uFF1A${(0, import_node_path3.basename)(path)}`);
+  }
+};
+async function withMutationLocks(paths, action) {
+  const releases = [];
+  try {
+    for (const path of [...new Set(paths)].sort()) releases.push(await acquireMutationLock(path));
+    return await action();
+  } finally {
+    for (const release of releases.reverse()) release();
+  }
+}
+async function acquireMutationLock(path) {
+  const previous = mutationQueues.get(path) ?? Promise.resolve();
+  let releaseGate;
+  const gate = new Promise((resolve5) => {
+    releaseGate = resolve5;
+  });
+  const tail = previous.catch(() => void 0).then(() => gate);
+  mutationQueues.set(path, tail);
+  await previous.catch(() => void 0);
+  return () => {
+    if (mutationQueues.get(path) === tail) mutationQueues.delete(path);
+    releaseGate();
+  };
+}
+async function removeIfIdentity(path, identity) {
+  try {
+    const stats = await (0, import_promises.lstat)(path, { bigint: true });
+    if (!stats.isSymbolicLink() && stats.isFile() && sameIdentity(identityOf(stats), identity)) await (0, import_promises.unlink)(path);
+  } catch {
+  }
+}
+function identityOf(stats) {
+  return { dev: stats.dev, ino: stats.ino };
+}
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function validateFileName(fileName) {
+  if (!fileName || fileName !== (0, import_node_path3.basename)(fileName) || (0, import_node_path3.isAbsolute)(fileName) || (0, import_node_path3.normalize)(fileName) !== fileName || fileName.includes("/") || fileName.includes("\\") || !fileName.endsWith(".yml") || fileName === ".yml" || fileName.includes("\0")) {
+    throw new PresetRepositoryError("invalid-file-name", `\u65E0\u6548\u9884\u8BBE\u6587\u4EF6\u540D\uFF1A${fileName}`);
+  }
+}
+function revisionOf(source2) {
+  return (0, import_node_crypto.createHash)("sha256").update(source2, "utf8").digest("hex");
+}
+function noFollowFlag() {
+  return typeof import_promises.constants.O_NOFOLLOW === "number" ? import_promises.constants.O_NOFOLLOW : 0;
+}
+function normalizeFileSystemError(error, fileName) {
+  if (error instanceof PresetRepositoryError) return error;
+  const code = error.code;
+  if (code === "ENOENT") return new PresetRepositoryError("not-found", `\u9884\u8BBE\u4E0D\u5B58\u5728\uFF1A${fileName}`, error);
+  if (code === "EEXIST") return new PresetRepositoryError("already-exists", `\u9884\u8BBE\u5DF2\u5B58\u5728\uFF1A${fileName}`, error);
+  if (code === "ELOOP") return new PresetRepositoryError("unsafe-file", `\u62D2\u7EDD\u8BBF\u95EE symlink \u9884\u8BBE\uFF1A${fileName}`, error);
+  return new PresetRepositoryError("unsafe-file", `\u65E0\u6CD5\u5B89\u5168\u8BBF\u95EE\u9884\u8BBE\uFF1A${fileName}`, error);
+}
+
+// src/presets/runtime-correlation.ts
+var PresetRuntimeSnapshotTracker = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    const on = ctx.on.bind(ctx);
+    this.disposers.push(on("chatluna/before-chat", (conversationId, _message, variables, chatInterface, session) => {
+      const target = this.resolveSession(session);
+      const presetName = readNestedString(variables, ["built", "preset"]);
+      if (!target || !presetName) return;
+      const preset = resolveCorePreset(chatInterface, this.ctx, presetName);
+      if (!preset) return;
+      const snapshot = snapshotCorePreset(presetName, preset);
+      if (!snapshot) return;
+      const turnId = `core:${conversationId}`;
+      const key = activeKey(target, `${turnId}:${this.nextCoreTurn++}`);
+      this.active.set(key, { target, turnId, snapshot });
+      const keys = this.coreTurnKeys.get(conversationId) ?? /* @__PURE__ */ new Set();
+      keys.add(key);
+      this.coreTurnKeys.set(conversationId, keys);
+    }));
+    this.disposers.push(on("chatluna/after-chat", (conversationId, _sourceMessage, _responseMessage, _variables, _chatInterface, session) => {
+      this.finishCore(conversationId, this.resolveSession(session));
+    }));
+    this.disposers.push(on("chatluna/after-chat-error", (_error, conversationId) => this.finishCore(conversationId)));
+    this.disposers.push(on("chatluna_character/before-chat", (payload) => {
+      const record = readRecord3(payload);
+      const target = this.resolveSession(record?.session);
+      const preset = readRecord3(record?.preset);
+      const presetName = readString2(record?.presetName) ?? readString2(preset?.name);
+      if (!target || !preset || !presetName) return;
+      const snapshot = snapshotCharacterPreset(presetName, preset);
+      if (!snapshot) return;
+      const turnId = `character:${this.nextCharacterTurn++}`;
+      const key = activeKey(target, turnId);
+      this.active.set(key, { target, turnId, snapshot });
+      const session = record?.session;
+      if (session && typeof session === "object") {
+        const keys = this.characterSessionTurnKeys.get(session) ?? /* @__PURE__ */ new Set();
+        keys.add(key);
+        this.characterSessionTurnKeys.set(session, keys);
+      }
+    }));
+    this.disposers.push(on("chatluna_character/after-chat", (payload) => {
+      const record = readRecord3(payload);
+      const target = this.resolveSession(record?.session);
+      if (!target) return;
+      const session = record?.session;
+      const sessionKeys = session && typeof session === "object" ? this.characterSessionTurnKeys.get(session) : void 0;
+      if (session && typeof session === "object" && sessionKeys?.size === 1) {
+        const [directKey] = sessionKeys;
+        if (directKey) this.active.delete(directKey);
+        this.characterSessionTurnKeys.delete(session);
+        return;
+      }
+      const matches = [...this.active].filter(([, turn]) => turn.snapshot.kind === "character" && sameTarget(turn.target, target));
+      if (matches.length === 1) this.active.delete(matches[0][0]);
+    }));
+  }
+  ctx;
+  active = /* @__PURE__ */ new Map();
+  coreTurnKeys = /* @__PURE__ */ new Map();
+  characterSessionTurnKeys = /* @__PURE__ */ new WeakMap();
+  disposers = [];
+  nextCoreTurn = 1;
+  nextCharacterTurn = 1;
+  getActiveSnapshots(target) {
+    const turns = [...this.active.values()].filter((turn) => sameTarget(turn.target, target));
+    const snapshots = ["core", "character"].flatMap((kind) => {
+      const matchingKind = turns.filter((turn) => turn.snapshot.kind === kind);
+      return matchingKind.length === 1 ? [matchingKind[0].snapshot] : [];
+    });
+    return structuredClone(snapshots);
+  }
+  dispose() {
+    for (const dispose of this.disposers.splice(0)) dispose();
+    this.active.clear();
+    this.coreTurnKeys.clear();
+  }
+  resolveSession(session) {
+    const record = readRecord3(session);
+    const bot = readRecord3(record?.bot);
+    const channel = readRecord3(record?.channel);
+    const botId = readString2(record?.selfId) ?? readString2(bot?.selfId);
+    const conversationId = readString2(record?.channelId) ?? readString2(channel?.id);
+    return botId && conversationId ? { botId, conversationId } : void 0;
+  }
+  finishCore(conversationId, target) {
+    const keys = this.coreTurnKeys.get(conversationId);
+    if (!keys) return;
+    const matches = [...keys].filter((key) => {
+      const turn = this.active.get(key);
+      return turn && (!target || sameTarget(turn.target, target));
+    });
+    if (matches.length !== 1) return;
+    this.active.delete(matches[0]);
+    keys.delete(matches[0]);
+    if (!keys.size) this.coreTurnKeys.delete(conversationId);
+  }
+};
+function snapshotCorePreset(presetName, preset) {
+  const templates = coreTemplates(preset);
+  if (!templates.length) return;
+  return structuredClone({
+    kind: "core",
+    presetName,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...typeof preset.rawText === "string" ? { source: preset.rawText } : {},
+    templates
+  });
+}
+function coreTemplates(preset) {
+  if (typeof preset.rawText === "string") {
+    const document = parsePresetSourceDocument("core", preset.rawText);
+    if (!document.diagnostics.length) {
+      const templates = document.templateFields.flatMap((field) => {
+        const role = coreRoleForPath(preset, field.path);
+        return role ? [{ path: field.path, role, template: field.value }] : [];
+      });
+      if (typeof preset.formatUserPromptString === "string" && !templates.some(({ path }) => path[0] === "format_user_prompt")) {
+        templates.push({ path: ["format_user_prompt"], role: "user", template: preset.formatUserPromptString });
+      }
+      return templates;
+    }
+  }
+  const messages = Array.isArray(preset.messages) ? preset.messages : [];
+  const result = messages.flatMap((message, index) => {
+    const record = readRecord3(message);
+    const content = readMessageContent(record?.content);
+    const role = readMessageRole(message);
+    return content !== void 0 && role ? [{ path: ["prompts", index, "content"], role, template: content }] : [];
+  });
+  if (typeof preset.formatUserPromptString === "string") {
+    result.push({ path: ["format_user_prompt"], role: "user", template: preset.formatUserPromptString });
+  }
+  return result;
+}
+function coreRoleForPath(preset, path) {
+  if (path[0] === "format_user_prompt") return "user";
+  const index = typeof path[1] === "number" ? path[1] : void 0;
+  return index === void 0 ? void 0 : readMessageRole(Array.isArray(preset.messages) ? preset.messages[index] : void 0);
+}
+function readMessageRole(message) {
+  const record = readRecord3(message);
+  const direct = readString2(record?.role)?.toLowerCase();
+  let type = direct;
+  const getType = record?._getType;
+  if (!type && typeof getType === "function") {
+    try {
+      type = readString2(getType.call(message))?.toLowerCase();
+    } catch {
+    }
+  }
+  if (type === "system" || type === "developer") return "system";
+  if (type === "human" || type === "user") return "user";
+  if (type === "ai" || type === "assistant") return "assistant";
+  if (type === "tool" || type === "function") return "tool";
+}
+function readMessageContent(value) {
+  if (typeof value === "string") return value;
+  const record = readRecord3(value);
+  return readString2(record?.text);
+}
+function snapshotCharacterPreset(presetName, preset) {
+  const system = typeof preset.system?.rawString === "string" ? preset.system.rawString : void 0;
+  const input = typeof preset.input?.rawString === "string" ? preset.input.rawString : void 0;
+  if (system === void 0 && input === void 0) return;
+  const templates = [];
+  if (system !== void 0) templates.push({ path: ["system"], role: "system", template: system });
+  if (input !== void 0) templates.push({ path: ["input"], role: "user", template: input });
+  return structuredClone({
+    kind: "character",
+    presetName,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: [system === void 0 ? void 0 : `system: ${system}`, input === void 0 ? void 0 : `input: ${input}`].filter(Boolean).join("\n"),
+    templates
+  });
+}
+function resolveCorePreset(chatInterface, ctx, presetName) {
+  const interfaceContext = readRecord3(readRecord3(chatInterface)?.ctx);
+  const candidates = [readRecord3(interfaceContext?.chatluna), readRecord3(readRecord3(ctx)?.chatluna)];
+  for (const chatluna of candidates) {
+    const service = readRecord3(chatluna?.preset);
+    const getPreset = service?.getPreset;
+    if (typeof getPreset !== "function") continue;
+    try {
+      const computed = getPreset.call(service, presetName, false);
+      const value = readRecord3(readRecord3(computed)?.value);
+      if (value) return value;
+    } catch {
+    }
+  }
+}
+function activeKey(target, turnId) {
+  return `${target.botId}\0${target.conversationId}\0${turnId}`;
+}
+function sameTarget(left, right) {
+  return left.botId === right.botId && left.conversationId === right.conversationId;
+}
+function readRecord3(value) {
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+function readString2(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function readNestedString(value, path) {
+  let current = value;
+  for (const key of path) current = readRecord3(current)?.[key];
+  return readString2(current);
+}
+
+// src/presets/service.ts
+var import_node_path4 = require("path");
+var StudioPresetService = class {
+  constructor(options) {
+    this.options = options;
+    this.repository = options.repository ?? new FileSystemPresetRepository({
+      coreRoot: (0, import_node_path4.resolve)(options.baseDir, "data/chathub/presets"),
+      characterRoot: (0, import_node_path4.resolve)(options.baseDir, "data/chathub/character/presets")
+    });
+  }
+  options;
+  repository;
+  async catalog(kind) {
+    const kinds = kind ? [kind] : ["core", "character"];
+    const files = await Promise.all(kinds.map((documentKind) => this.repository.readAll(documentKind)));
+    return files.flat().map((file) => this.present(file)).sort((left, right) => left.kind.localeCompare(right.kind) || left.displayName?.localeCompare(right.displayName ?? "") || left.fileName.localeCompare(right.fileName));
+  }
+  async read(input) {
+    return this.present(await this.repository.read(input.kind, input.fileName));
+  }
+  async create(input) {
+    return this.present(await this.repository.create(input));
+  }
+  async save(input) {
+    return this.present(await this.repository.save(input));
+  }
+  async rename(input) {
+    return this.present(await this.repository.rename(input));
+  }
+  async delete(input) {
+    await this.repository.delete(input);
+    return { deleted: true };
+  }
+  async locateExpression(input) {
+    let document;
+    try {
+      document = await this.read(input.document);
+    } catch (error) {
+      if (error instanceof PresetRepositoryError && error.code === "not-found") {
+        return failure("document-not-found", error.message);
+      }
+      throw error;
+    }
+    if (document.revision !== input.document.revision) {
+      return failure("document-stale", "\u9884\u8BBE\u6E90\u7801 revision \u5DF2\u53D8\u5316\uFF0C\u8BF7\u5237\u65B0\u540E\u91CD\u8BD5");
+    }
+    if (!document.displayName) {
+      return failure("document-identity-unavailable", "\u9884\u8BBE\u7F3A\u5C11\u53EF\u7528\u4E8E\u8FD0\u884C\u65F6\u5173\u8054\u7684\u5C55\u793A\u8EAB\u4EFD");
+    }
+    const expression = resolveExpression(document.expressions, input.expression);
+    if (!expression) return failure("expression-not-found", "\u9884\u8BBE\u8868\u8FBE\u5F0F\u4E0D\u5B58\u5728\u6216\u5750\u6807\u5DF2\u53D8\u5316");
+    const recordAndSnapshot = await findLatestMatchingRequest(this.options.modelRequests, document);
+    if (!recordAndSnapshot) {
+      return failure("request-not-observed", "\u8BB0\u5F55\u5E93\u91CC\u6CA1\u6709\u4F7F\u7528\u8BE5\u9884\u8BBE\u5F53\u524D\u6A21\u677F\u7684\u6709\u5F52\u5C5E\u6210\u529F\u6A21\u578B\u8BF7\u6C42");
+    }
+    const { record, snapshot } = recordAndSnapshot;
+    const result = matchPresetExpressionEvidence({
+      document: {
+        kind: document.kind,
+        source: document.source,
+        templateFields: document.templateFields,
+        expressions: document.expressions,
+        diagnostics: document.diagnostics
+      },
+      expression,
+      snapshot,
+      evidence: projectModelEvidence({
+        requestBody: record.requestBody,
+        responseBodyRaw: record.responseBodyRaw,
+        responseBodyFormat: record.responseBodyFormat
+      })
+    });
+    if (result.status === "matched") {
+      return {
+        status: "matched",
+        recordId: record.id,
+        evidenceId: result.evidenceId,
+        range: result.range
+      };
+    }
+    if (result.status === "stale") return failure("expression-stale", "\u8868\u8FBE\u5F0F\u6216\u8FD0\u884C\u65F6\u6A21\u677F\u5DF2\u53D8\u5316");
+    if (result.status === "not-observed") return failure("expression-not-observed", "\u6A21\u578B\u8BF7\u6C42\u8BC1\u636E\u4E2D\u672A\u89C2\u5BDF\u5230\u8BE5\u8868\u8FBE\u5F0F\u7684\u5C55\u5F00\u8303\u56F4");
+    if (result.status === "ambiguous") return failure("expression-ambiguous", "\u6A21\u578B\u8BF7\u6C42\u8BC1\u636E\u4E2D\u5B58\u5728\u591A\u4E2A\u53EF\u80FD\u8303\u56F4\uFF0C\u65E0\u6CD5\u552F\u4E00\u5B9A\u4F4D");
+    return {
+      ...failure("expression-unsupported", "\u8BE5\u8868\u8FBE\u5F0F\u4E0D\u80FD\u6620\u5C04\u4E3A\u7CBE\u786E\u6A21\u578B\u8BC1\u636E\u8303\u56F4"),
+      reason: result.reason
+    };
+  }
+  present(file) {
+    return {
+      kind: file.kind,
+      fileName: file.fileName,
+      displayName: file.document.displayName,
+      source: file.source,
+      revision: file.revision,
+      size: file.size,
+      modifiedAt: file.modifiedAt,
+      templateFields: structuredClone(file.document.templateFields),
+      expressions: file.document.expressions.map((expression) => ({
+        ...structuredClone(expression),
+        stableId: expressionStableId(expression)
+      })),
+      diagnostics: structuredClone(file.document.diagnostics)
+    };
+  }
+};
+function expressionStableId(expression) {
+  return `${JSON.stringify(expression.path)}#${expression.occurrence}`;
+}
+function resolveExpression(expressions, identity) {
+  if ("stableId" in identity) return expressions.find(({ stableId }) => stableId === identity.stableId);
+  return expressions.find((expression) => expression.occurrence === identity.occurrence && samePath2(expression.path, identity.path) && expression.range.start === identity.range.start && expression.range.end === identity.range.end);
+}
+async function findLatestMatchingRequest(store, document) {
+  let beforeSequence;
+  do {
+    const page = await store.getRecords({ attribution: "attributed", order: "desc", limit: 200, beforeSequence });
+    for (const item of page.records) {
+      if (item.status !== "success" || !item.requestBodyAvailable) continue;
+      if (!item.presetSnapshotSummaries?.some((snapshot2) => snapshot2.kind === document.kind && snapshot2.presetName === document.displayName)) continue;
+      const record = await store.getRecord(item.id);
+      if (!record || record.requestBody === void 0) continue;
+      const snapshot = record.presetSnapshots?.find((candidate) => snapshotMatchesDocument(candidate, document));
+      if (snapshot) return { record, snapshot };
+    }
+    beforeSequence = page.nextCursor;
+    if (!page.hasMore) return;
+  } while (beforeSequence !== void 0);
+}
+function snapshotMatchesDocument(snapshot, document) {
+  if (snapshot.kind !== document.kind || snapshot.presetName !== document.displayName) return false;
+  if (snapshot.source === document.source) return true;
+  if (snapshot.templates.length !== document.templateFields.length) return false;
+  return document.templateFields.every((field) => snapshot.templates.some((template) => samePath2(template.path, field.path) && template.template === field.value));
+}
+function samePath2(left, right) {
+  return left.length === right.length && left.every((part, index) => part === right[index]);
+}
+function failure(code, message) {
+  return { status: "failed", code, message };
+}
+
+// src/index.ts
+var name = "chatluna-studio";
+var usage = `
+\u5728 Koishi \u63A7\u5236\u53F0\u91CC\u67E5\u770B ChatLuna \u7684\u771F\u5B9E\u6A21\u578B\u8BF7\u6C42\uFF0C\u5E76\u76F4\u63A5\u7F16\u8F91 ChatLuna \u4E0E chatluna-character \u7684\u9884\u8BBE\u6587\u4EF6\u3002
+
+- \u6A21\u578B\u8BF7\u6C42\u9875\u9762\u8BB0\u5F55\u6BCF\u6B21\u771F\u5B9E\u5BF9\u8BDD\u89E6\u53D1\u7684\u6A21\u578B\u8C03\u7528\uFF1A\u8BF7\u6C42\u4F53\u3001\u54CD\u5E94\u539F\u6587\u3001\u7528\u91CF\u3001\u8F68\u8FF9\u4E0E\u9884\u8BBE\u53D8\u91CF\u5C55\u5F00\u3002
+- \u9884\u8BBE\u9875\u9762\u76F4\u63A5\u8BFB\u5199\`data/chathub/presets\`\u4E0E\`data/chathub/character/presets\`\u4E0B\u7684 YAML \u6587\u4EF6\uFF0C\u4FDD\u5B58\u540E\u7531 ChatLuna \u81EA\u5DF1\u70ED\u91CD\u8F7D\u3002
+- \u70B9\u51FB\u9884\u8BBE\u91CC\u7684\u8868\u8FBE\u5F0F\u53EF\u4EE5\u8DF3\u5230\u5B83\u5728\u771F\u5B9E\u6A21\u578B\u8BF7\u6C42\u4E2D\u7684\u5C55\u5F00\u4F4D\u7F6E\uFF0C\u9700\u8981\u5148\u6709\u4E00\u6B21\u7528\u5230\u8BE5\u9884\u8BBE\u7684\u6210\u529F\u8BF7\u6C42\u3002
+
+\u6A21\u578B\u8BF7\u6C42\u7684\u91C7\u96C6\u5728 ChatLuna \u7684 fetch \u8FB9\u754C\u5B8C\u6210\uFF0C\u56E0\u6B64\u9700\u8981\u4E0E ChatLuna \u88C5\u5728\u540C\u4E00\u4E2A Koishi \u5B9E\u4F8B\u91CC\u3002
+`;
+var inject = {
+  required: ["console"],
+  optional: ["database"]
+};
+var Config = import_koishi3.Schema.object({
+  persistenceMode: import_koishi3.Schema.union([
+    import_koishi3.Schema.const("memory").description("\u670D\u52A1\u7AEF\u5185\u5B58"),
+    import_koishi3.Schema.const("database").description("Koishi Database")
+  ]).default("database").role("radio").description("\u6A21\u578B\u8BF7\u6C42\u8BB0\u5F55\u7684\u5B58\u50A8\u65B9\u5F0F\u3002\u5185\u5B58\u6A21\u5F0F\u91CD\u542F\u540E\u8BB0\u5F55\u6E05\u7A7A"),
+  modelRequestRecordLimit: import_koishi3.Schema.number().min(1).default(DEFAULT_MODEL_REQUEST_RECORD_LIMIT).description("\u4FDD\u7559\u7684\u6A21\u578B\u8BF7\u6C42\u8BB0\u5F55\u6761\u6570\u4E0A\u9650\uFF0C\u8D85\u51FA\u540E\u4ECE\u6700\u65E7\u8BB0\u5F55\u5F00\u59CB\u4E22\u5F03"),
+  studioColorMode: import_koishi3.Schema.union([
+    import_koishi3.Schema.const("auto").description("\u81EA\u52A8"),
+    import_koishi3.Schema.const("light").description("\u660E\u4EAE"),
+    import_koishi3.Schema.const("dark").description("\u6697\u8272")
+  ]).default("auto").role("radio").description("\u9875\u9762\u989C\u8272\u6A21\u5F0F\u3002\u81EA\u52A8\u65F6\u8DDF\u968F Koishi \u63A7\u5236\u53F0"),
+  studioAccentColor: import_koishi3.Schema.string().default("#2563eb").role("color").description("\u9875\u9762\u5F3A\u8C03\u8272"),
+  enableStudioFrostedGlass: import_koishi3.Schema.boolean().default(true).description("\u542F\u7528\u6D6E\u5C42\u6BDB\u73BB\u7483\u6548\u679C"),
+  studioUseQQAvatars: import_koishi3.Schema.boolean().default(true).description("\u4ECE QQ \u5934\u50CF CDN \u52A0\u8F7D\u673A\u5668\u4EBA\u4E0E\u4F1A\u8BDD\u5934\u50CF\u3002\u5173\u95ED\u540E\u53EA\u663E\u793A\u9996\u5B57\u6BCD\u8272\u5757\uFF0C\u6D4F\u89C8\u5668\u4E0D\u4F1A\u5411`q.qlogo.cn`\u53D1\u8D77\u8BF7\u6C42")
+}).description("ChatLuna Studio");
+function findChatLunaUsage(ctx) {
+  for (const runtime of ctx.registry.values()) {
+    const service = runtime.ctx.get("console.services.chatluna_usage");
+    if (service) return service;
+  }
+}
+function apply(ctx, config) {
+  ctx.inject({
+    console: { required: true },
+    database: { required: false }
+  }, (inner) => {
+    const logger = inner.logger("chatluna-studio");
+    let persistence;
+    if (config.persistenceMode === "database") {
+      registerStudioModelRequestModel(inner);
+      persistence = new KoishiDatabaseModelRequestPersistence(() => inner.database);
+    }
+    const modelRequests = new StudioModelRequestStore({
+      ...persistence ? { persistence } : {},
+      maxRecords: config.modelRequestRecordLimit
+    });
+    const presetSnapshots = new PresetRuntimeSnapshotTracker(inner);
+    const sessions = new ChatLunaSessionTracker(inner, {
+      // ChatLuna 规范错误只出现在对话链路的错误事件里，而模型请求记录只看得到 HTTP 层的失败；
+      // 把它回填到本轮最近一条失败记录上，详情页才能给出错误码与可能原因。
+      onTurnFailed: (error, turn) => {
+        const conversationId = turn.entities.conversationId;
+        if (conversationId) archiveChatLunaModelRequestError(modelRequests, error, { conversationId });
+      }
+    });
+    const presets = new StudioPresetService({ baseDir: inner.baseDir, modelRequests });
+    const getPersistenceStatus = () => {
+      if (config.persistenceMode !== "database") {
+        return { mode: "memory", available: true, persisted: false };
+      }
+      const available = Boolean(inner.database);
+      return {
+        mode: "database",
+        available,
+        persisted: available,
+        ...available ? {} : { message: "Koishi Database \u670D\u52A1\u672A\u5B89\u88C5\u6216\u4E0D\u53EF\u7528\uFF0C\u6A21\u578B\u8BF7\u6C42\u8BB0\u5F55\u4E0D\u4F1A\u843D\u76D8" }
+      };
+    };
+    const notifyRecorded = registerConsole(inner.console, {
+      modelRequests,
+      presets,
+      appearance: {
+        enableStudioFrostedGlass: config.enableStudioFrostedGlass,
+        studioColorMode: config.studioColorMode,
+        studioAccentColor: config.studioAccentColor,
+        studioUseQQAvatars: config.studioUseQQAvatars
+      },
+      getPersistenceStatus,
+      // chatluna-usage 位于另一个 loader group，Cordis 会为服务建立隔离映射；
+      // 复用 usage 插件的 Context 才能解析到同一实例。
+      chatlunaUsage: () => findChatLunaUsage(inner)
+    });
+    const chatLunaPlugin = resolveChatLunaPluginClass(inner.baseDir);
+    const disposeCollector = installModelRequestCollector({
+      ...chatLunaPlugin ? { plugin: chatLunaPlugin } : {},
+      baseDir: inner.baseDir,
+      store: modelRequests,
+      resolveTurn: () => sessions.resolveActiveTurn(),
+      getActivePresetSnapshots: (target) => presetSnapshots.getActiveSnapshots(target),
+      onRecordAppended: ({ sequence }) => notifyRecorded(sequence)
+    });
+    logger.info(chatLunaPlugin ? "ChatLuna \u6A21\u578B\u8BF7\u6C42\u91C7\u96C6\u5668\u5DF2\u5B89\u88C5\u3002" : "\u672A\u627E\u5230 ChatLuna \u8FD0\u884C\u65F6\uFF0C\u6A21\u578B\u8BF7\u6C42\u91C7\u96C6\u5668\u672A\u5B89\u88C5\u3002");
+    inner.on("chatluna/model-usage", (payload) => {
+      void linkChatLunaUsageRequest([modelRequests], payload).catch((error) => {
+        logger.warn("ChatLuna \u7528\u91CF\u4E8B\u4EF6\u5173\u8054\u6A21\u578B\u8BF7\u6C42\u5931\u8D25\u3002", error);
+      });
+    });
+    inner.on("dispose", () => {
+      disposeCollector();
+      presetSnapshots.dispose();
+      sessions.dispose();
+      void modelRequests.waitForPersistence().catch((error) => {
+        logger.error("\u6A21\u578B\u8BF7\u6C42\u8BB0\u5F55\u5173\u673A\u6536\u5C3E\u6301\u4E45\u5316\u5931\u8D25\u3002", error);
+      });
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CHATLUNA_ERROR_CODE_DOCUMENTATION_URL,
+  ChatLunaSessionTracker,
+  Config,
+  DEFAULT_MODEL_REQUEST_PAGE_SIZE,
+  DEFAULT_MODEL_REQUEST_RECORD_LIMIT,
+  DEFAULT_MODEL_REQUEST_RECORD_MAX_BYTES,
+  FileSystemPresetRepository,
+  InMemoryModelRequestRecords,
+  InMemoryRecordRows,
+  KoishiDatabaseModelRequestPersistence,
+  MAX_MODEL_REQUEST_PAGE_SIZE,
+  MODEL_REQUEST_FACET_SCAN_LIMIT,
+  PresetRepositoryError,
+  PresetRuntimeSnapshotTracker,
+  STUDIO_EVIDENCE_AGGREGATE_IDS,
+  STUDIO_EVIDENCE_KINDS,
+  ScopeRowIndex,
+  SerialWriteQueue,
+  StudioDomainError,
+  StudioModelRequestCursorExpiredError,
+  StudioModelRequestStore,
+  StudioPresetService,
+  apply,
+  archiveChatLunaModelRequestError,
+  buildStudioModelRequestTrajectory,
+  buildStudioModelRequestTrajectoryFromStore,
+  countMessageCharacters,
+  countToolCallCharacters,
+  countToolDefinitionCharacters,
+  createModelRequestError,
+  deriveModelRequestVariables,
+  estimateModelRequestRecordBytes,
+  expressionStableId,
+  findLatestFailedModelRequest,
+  getChatLunaErrorPossibleCauses,
+  inferModelResponseBodyFormat,
+  inject,
+  installModelRequestCollector,
+  isKnownChatModelRequestUrl,
+  isStudioEvidenceAggregateMember,
+  isVirtualOneBotSession,
+  linkChatLunaUsageRequest,
+  lookupChatLunaUsage,
+  matchPresetExpressionEvidence,
+  matchesModelRequestQuery,
+  modelRequestVariableStatusLabel,
+  name,
+  parsePresetSourceDocument,
+  presentModelRequestDetail,
+  presentModelRequestListItem,
+  projectModelEvidence,
+  readChatLunaRequestError,
+  readStudioModelRequestConversationRecords,
+  readStudioSessionEntities,
+  registerConsole,
+  registerStudioModelRequestModel,
+  resolveChatLunaPluginClass,
+  resolveConsoleEntry,
+  resolveModelRequestOrder,
+  sanitizeModelRequestUrl,
+  statusLabel,
+  studioEvidenceAggregate,
+  studioEvidenceLabels,
+  toModelRequestRecordHeader,
+  toStudioModelRequestUsage,
+  usage
+});