linkque-cli-v2 1.0.5 → 1.0.7

package/vendor/linkque-agent-appwrite-integrate/dist/esm/runtime/handler/chat.js

@@ -0,0 +1,2348 @@
+import {
+  LinkqueGatewayAuthError,
+  LinkqueGatewayAuthUnconfiguredError,
+  Query,
+  createAppBaseClient,
+  createClientCapabilityStore,
+  describeRuntimeEnv,
+  isDebugLogLevel,
+  jsonError,
+  parseStoredClientCapabilityResult,
+  readAppwriteApiKey,
+  readAuthenticatedUserId,
+  readEnvSelector,
+  readTraceId,
+  resolveBodyJSON,
+  resolveGatewayAuthContext,
+  resolveLinkqueGatewayAuth,
+  resolveRunStorage,
+  toAgentRunMessages
+} from "../../chunk-IAT272TH.js";
+import "../../chunk-MKS245OU.js";
+import "../../chunk-YDKZZ6EH.js";
+import "../../chunk-2NGJGNYB.js";
+import {
+  AgentRuntime,
+  CANCEL_CONVERSATION_RUN_OPERATION,
+  CONVERSATION_HISTORY_VERSION,
+  ConversationControlValidationError,
+  ConversationHistoryValidationError,
+  ConversationProtocolValidationError,
+  DEFAULT_CONVERSATION_LIST_LIMIT,
+  DEFAULT_CONVERSATION_RUN_LIST_LIMIT,
+  DEFAULT_CONVERSATION_SEARCH_LIMIT,
+  EResourceType,
+  ESkillUrlScheme,
+  EventType,
+  FOLLOW_UP_CONTEXT_MAX_HISTORY_RUNS,
+  LinkqueKnowledgeSearchPort,
+  LinkquegwEventHookExecutor,
+  RemoteGatewayMcpServerProvider,
+  WebSkillLoader,
+  encodeConversationSseEvent,
+  executeHomeData,
+  getBakedProtocol,
+  parseCancelConversationRunRequest,
+  parseConversationFollowUpQuestions,
+  parseConversationHistoryRequest,
+  parseConversationRunRequest,
+  parseSkillFile,
+  streamToConversationEvents
+} from "../../chunk-FJ2BZPIM.js";
+import "../../chunk-XUFLSZM4.js";
+import "../../chunk-I64V3ICJ.js";
+import "../../chunk-6MHDOBWO.js";
+import "../../chunk-E2P6TIFG.js";
+import "../../chunk-3S3TOEBZ.js";
+import "../../chunk-OXGCUIKV.js";
+import "../../chunk-DYEQRE6N.js";
+import "../../chunk-46SEH6ER.js";
+import "../../chunk-VS2QQHAK.js";
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/handler/chat.js
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/ports/appbaseSessionManager.js
+var AppbaseSessionManager = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  async load(sessionId) {
+    const row = await this.store.read(sessionId);
+    if (!row)
+      return [];
+    return row.turns.map((json) => safeParseTurn(json)).filter((t) => t !== void 0);
+  }
+  async append(sessionId, turn) {
+    const existing = await this.store.read(sessionId);
+    if (!existing) {
+      await this.store.create(sessionId);
+    }
+    await this.store.append(sessionId, JSON.stringify(turn));
+  }
+  async appendMany(sessionId, turns) {
+    const serialized = turns.map((turn) => JSON.stringify(turn));
+    if (this.store.appendMany) {
+      await this.store.appendMany(sessionId, serialized);
+      return;
+    }
+    for (const turn of turns) {
+      await this.append(sessionId, turn);
+    }
+  }
+};
+function createAppbaseSessionManager(store) {
+  return new AppbaseSessionManager(store);
+}
+function safeParseTurn(json) {
+  try {
+    const value = JSON.parse(json);
+    if (value && typeof value === "object" && "role" in value)
+      return value;
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function createAppBaseSessionStore(databases, databaseId, tableId) {
+  return {
+    read: async (sessionId) => storesRead(databases, databaseId, tableId, sessionId),
+    create: async (sessionId) => {
+      await databases.createDocument(databaseId, tableId, sessionId, {
+        sessionId,
+        turns: []
+      });
+      return { sessionId, turns: [] };
+    },
+    append: async (sessionId, turnJson) => {
+      await appendSerializedTurns(databases, databaseId, tableId, sessionId, [
+        turnJson
+      ]);
+    },
+    appendMany: async (sessionId, turnJsons) => {
+      await appendSerializedTurns(databases, databaseId, tableId, sessionId, turnJsons);
+    }
+  };
+}
+async function appendSerializedTurns(databases, databaseId, tableId, sessionId, turnJsons) {
+  const row = await storesRead(databases, databaseId, tableId, sessionId);
+  const turns = row ? [...row.turns, ...turnJsons] : [...turnJsons];
+  if (row) {
+    await databases.updateDocument(databaseId, tableId, sessionId, { turns });
+  } else {
+    await databases.createDocument(databaseId, tableId, sessionId, {
+      sessionId,
+      turns
+    });
+  }
+}
+async function storesRead(databases, databaseId, tableId, sessionId) {
+  try {
+    const doc = await databases.getDocument(databaseId, tableId, sessionId);
+    const turns = doc.turns;
+    if (!Array.isArray(turns))
+      return void 0;
+    return { sessionId, turns };
+  } catch (err) {
+    if (isNotFound(err))
+      return void 0;
+    throw err;
+  }
+}
+function isNotFound(err) {
+  if (!err)
+    return false;
+  const e = err;
+  if (e.code === 404)
+    return true;
+  return /not found|404/i.test(e.message ?? "");
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/ports/appbaseSkillLoader.js
+var AppbaseSkillLoader = class {
+  resolveContent;
+  constructor(options = {}) {
+    this.resolveContent = options.resolveContent;
+  }
+  async load(resources) {
+    if (!this.resolveContent || resources.length === 0)
+      return [];
+    const raws = await Promise.all(resources.map((r) => this.resolveContent(r)));
+    const records = [];
+    for (let i = 0; i < raws.length; i += 1) {
+      const raw = raws[i];
+      if (typeof raw !== "string" || raw.length === 0)
+        continue;
+      const record = parseSkillFile(raw, resources[i]?.resourceId ?? "skill");
+      if (record)
+        records.push(record);
+    }
+    return records;
+  }
+};
+function createAppbaseSkillLoader(options = {}) {
+  if (options.resolveContent) {
+    return new AppbaseSkillLoader(options);
+  }
+  return new WebSkillLoader({
+    allowedSchemes: [ESkillUrlScheme.HTTP, ESkillUrlScheme.HTTPS],
+    ...options.debugLog ? { debugLog: options.debugLog } : {}
+  });
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/ports/appbaseMcpProvider.js
+var DEFAULT_OPEN_MCP_BASE_URL = "https://opengw.alipay.com";
+function createAppbaseMcpConfigResolver(options) {
+  return (resource) => ({
+    remoteBaseUrl: DEFAULT_OPEN_MCP_BASE_URL,
+    sseEndpoint: `api/v1/open/mcps/${resource.config.serverName}/sse`,
+    agentId: options.agentId,
+    ...options.signEndpoint ? { signEndpoint: options.signEndpoint } : {}
+  });
+}
+function createAppbaseMcpProvider(options = {}) {
+  if (!options.resolveConfig) {
+    return {
+      async servers() {
+        return [];
+      }
+    };
+  }
+  return new RemoteGatewayMcpServerProvider({
+    resolveConfig: options.resolveConfig,
+    ...options.getAuthorizationHeader ? { getAuthorizationHeader: options.getAuthorizationHeader } : {},
+    ...options.debugLog ? { debugLog: options.debugLog } : {}
+  });
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/runtimeFactory.js
+function resolveSessionLeaseStorage(env = process.env) {
+  const databaseId = env.SESSION_LEASE_DATABASE_ID ?? env.SESSION_DATABASE_ID;
+  const tableId = env.SESSION_LEASE_TABLE_ID;
+  if (!databaseId || !tableId)
+    return void 0;
+  return { databaseId, tableId };
+}
+function resolveSessionStorage(env = process.env) {
+  const databaseId = env.SESSION_DATABASE_ID ?? env.RUN_DATABASE_ID;
+  const tableId = env.SESSION_TABLE_ID ?? env.RUN_TABLE_ID;
+  if (!databaseId || !tableId)
+    return void 0;
+  return { databaseId, tableId };
+}
+function trimEnvVar(v) {
+  const t = v?.trim();
+  return t ? t : void 0;
+}
+function resolveLinkqueEndpoints(env, envSelector) {
+  const isPre = envSelector === "PRE";
+  return {
+    linkqueBaseUrl: trimEnvVar(isPre ? env.LINKQUE_BASE_URL_PRE : env.LINKQUE_BASE_URL),
+    knowledgeBaseUrl: trimEnvVar(isPre ? env.LINKQUEGW_KNOWLEDGE_BASE_URL_PRE : env.LINKQUEGW_KNOWLEDGE_BASE_URL),
+    mcpSignEndpoint: trimEnvVar(isPre ? env.LINKQUEGW_MCP_SIGN_ENDPOINT_PRE : env.LINKQUEGW_MCP_SIGN_ENDPOINT)
+  };
+}
+function createAppBaseRuntime(protocol, env = process.env, ports = {}, logCtx) {
+  const log = (...a) => logCtx?.log?.("[runtime-factory]", ...a);
+  const debugLog = logCtx?.log ? (line, scope) => {
+    const prefix = scope ? `[${scope}] ` : "";
+    logCtx.log?.(prefix + line);
+  } : void 0;
+  const runtimePorts = {};
+  if (ports.linkqueBaseUrl) {
+    runtimePorts.linkqueBaseUrl = ports.linkqueBaseUrl;
+    log("linkqueBaseUrl: ->", ports.linkqueBaseUrl);
+  }
+  if (ports.sessionManager) {
+    runtimePorts.sessionManager = ports.sessionManager;
+    log("sessionManager: \u4F7F\u7528\u6CE8\u5165\u5B9E\u73B0");
+  } else {
+    const sessionCfg = resolveSessionStorage(env);
+    if (sessionCfg) {
+      try {
+        const handle = createAppBaseClient(env, logCtx, ports.appBaseApiKey);
+        const store = createAppBaseSessionStore(handle.databases, sessionCfg.databaseId, sessionCfg.tableId);
+        runtimePorts.sessionManager = createAppbaseSessionManager(store);
+        log("sessionManager: AppBase \u6301\u4E45\u5316, databaseId=", sessionCfg.databaseId, "tableId=", sessionCfg.tableId);
+      } catch (err) {
+        log("sessionManager: AppBase \u51ED\u636E\u7F3A\u5931,\u56DE\u9000 InMemory, \u539F\u56E0=", err instanceof Error ? err.message : err);
+      }
+    } else {
+      log("sessionManager: \u65E0 session table \u914D\u7F6E,\u56DE\u9000 InMemory");
+    }
+  }
+  runtimePorts.skillLoader = ports.skillLoader ?? createAppbaseSkillLoader({ debugLog });
+  log("skillLoader:", ports.skillLoader ? "\u4F7F\u7528\u6CE8\u5165\u5B9E\u73B0" : "AppbaseSkillLoader(\u9ED8\u8BA4)");
+  runtimePorts.mcpServerProvider = ports.mcpServerProvider ?? createAppbaseMcpProvider({
+    ...ports.mcpConfigResolver ? { resolveConfig: ports.mcpConfigResolver } : {},
+    ...ports.mcpAuthorizationHeaderProvider ? { getAuthorizationHeader: ports.mcpAuthorizationHeaderProvider } : {},
+    ...debugLog ? { debugLog } : {}
+  });
+  log("mcpServerProvider:", ports.mcpServerProvider ? "\u4F7F\u7528\u6CE8\u5165\u5B9E\u73B0" : ports.mcpConfigResolver ? "RemoteGateway(\u9ED8\u8BA4)" : "AppbaseMcpProvider noop(\u9ED8\u8BA4)");
+  const mcpAuthHeader = ports.mcpAuthorizationHeaderProvider;
+  runtimePorts.knowledgeSearchPort = ports.knowledgeSearchPort ?? (mcpAuthHeader ? new LinkqueKnowledgeSearchPort({
+    baseUrl: ports.knowledgeBaseUrl,
+    getAuthHeaders: async () => ({
+      authorization: await mcpAuthHeader(),
+      ...ports.gatewayAgentId ? { "x-linkque-agent-id": ports.gatewayAgentId } : {}
+    }),
+    ...debugLog ? { debugLog } : {}
+  }) : void 0);
+  log("knowledgeSearchPort:", ports.knowledgeSearchPort ? "\u4F7F\u7528\u6CE8\u5165\u5B9E\u73B0" : mcpAuthHeader ? "LinkqueKnowledgeSearchPort(\u9274\u6743\u5934\u6A21\u5F0F,\u9ED8\u8BA4\u6D3E\u751F)" : "Noop(\u9ED8\u8BA4,\u65E0\u9274\u6743\u5934\u6E90)");
+  runtimePorts.hookExecutor = ports.hookExecutor ?? (mcpAuthHeader ? new LinkquegwEventHookExecutor({
+    baseUrl: ports.knowledgeBaseUrl,
+    getAuthHeaders: async () => ({
+      authorization: await mcpAuthHeader(),
+      ...ports.gatewayAgentId ? { "x-linkque-agent-id": ports.gatewayAgentId } : {}
+    }),
+    ...debugLog ? { debugLog } : {}
+  }) : void 0);
+  log("hookExecutor:", ports.hookExecutor ? "\u4F7F\u7528\u6CE8\u5165\u5B9E\u73B0" : mcpAuthHeader ? "LinkquegwEventHookExecutor(\u9274\u6743\u5934\u6A21\u5F0F,\u9ED8\u8BA4\u6D3E\u751F)" : "Noop(\u9ED8\u8BA4,\u65E0\u9274\u6743\u5934\u6E90)");
+  if (debugLog) {
+    runtimePorts.debugLog = debugLog;
+    log("debugLog: \u6CE8\u5165 runtime(\u7EDF\u4E00 ctx.log sink)");
+  }
+  log("AgentRuntime \u88C5\u914D\u5B8C\u6210, agentId=", protocol.agentId, "model=", protocol.agent.model.defaultModel);
+  return AgentRuntime.create(protocol, runtimePorts);
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/handler/asr.js
+var ASR_CREATE_CREDENTIAL_OPERATION = "asr.createCredential";
+async function runAsrCredential(method, env, authenticatedUserId, agentId, fetchImpl = fetch, envSelector, gatewayAuth, logCtx) {
+  if (method !== "POST")
+    return jsonError(405, "method_not_allowed", "\u4EC5\u652F\u6301 POST");
+  if (!authenticatedUserId) {
+    return jsonError(401, "authentication_required", "\u7F3A\u5C11 Appwrite \u8BA4\u8BC1\u7528\u6237");
+  }
+  let resolvedAuth;
+  try {
+    resolvedAuth = resolveGatewayAuthContext(gatewayAuth, env, logCtx, "asr");
+  } catch {
+    return jsonError(500, "auth_unconfigured", "linkquegw AAK \u672A\u914D\u7F6E");
+  }
+  const gatewayBaseUrl = resolveLinkqueEndpoints(env, envSelector).knowledgeBaseUrl;
+  if (!gatewayBaseUrl) {
+    return jsonError(500, "gateway_unconfigured", "linkquegw \u5730\u5740\u672A\u914D\u7F6E");
+  }
+  let response;
+  try {
+    response = await fetchImpl(`${gatewayBaseUrl}/api/asr/credential`, {
+      method: "POST",
+      headers: {
+        Authorization: resolvedAuth.authorizationHeader,
+        "x-linkque-agent-id": agentId
+      }
+    });
+  } catch {
+    return jsonError(502, "asr_gateway_unavailable", "\u5B9E\u65F6\u8BED\u97F3\u7B7E\u540D\u670D\u52A1\u4E0D\u53EF\u7528");
+  }
+  const payload = await response.json().catch(() => void 0);
+  const credential = payload?.data;
+  if (!response.ok || payload?.success !== true || typeof credential?.appKey !== "string" || typeof credential.digest !== "string" || typeof credential.timestamp !== "string") {
+    const message = typeof payload?.errorMessage === "string" ? payload.errorMessage : `\u5B9E\u65F6\u8BED\u97F3\u7B7E\u540D\u670D\u52A1\u8FD4\u56DE\u5F02\u5E38\uFF08${response.status}\uFF09`;
+    return jsonError(response.status >= 500 ? 502 : response.status, "asr_credential_failed", message);
+  }
+  return {
+    status: 200,
+    body: {
+      operation: ASR_CREATE_CREDENTIAL_OPERATION,
+      credential: {
+        appKey: credential.appKey,
+        digest: credential.digest,
+        timestamp: credential.timestamp
+      }
+    }
+  };
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/handler/attachment.js
+var ATTACHMENT_CREATE_UPLOAD_TOKEN_OPERATION = "attachment.createUploadToken";
+async function runAttachmentUploadToken(method, env, authenticatedUserId, agentId, fetchImpl = fetch, envSelector, gatewayAuth, logCtx) {
+  if (method !== "POST") {
+    return jsonError(405, "method_not_allowed", "\u4EC5\u652F\u6301 POST");
+  }
+  if (!authenticatedUserId) {
+    return jsonError(401, "authentication_required", "\u7F3A\u5C11 Appwrite \u8BA4\u8BC1\u7528\u6237");
+  }
+  let resolvedAuth;
+  try {
+    resolvedAuth = resolveGatewayAuthContext(gatewayAuth, env, logCtx, "attachment");
+  } catch {
+    return jsonError(500, "auth_unconfigured", "linkquegw AAK \u672A\u914D\u7F6E");
+  }
+  const gatewayBaseUrl = resolveLinkqueEndpoints(env, envSelector).knowledgeBaseUrl;
+  if (!gatewayBaseUrl) {
+    return jsonError(500, "gateway_unconfigured", "linkquegw \u5730\u5740\u672A\u914D\u7F6E");
+  }
+  let response;
+  try {
+    response = await fetchImpl(`${gatewayBaseUrl}/api/mass/token`, {
+      method: "POST",
+      headers: {
+        Authorization: resolvedAuth.authorizationHeader,
+        "content-type": "application/json",
+        "x-linkque-agent-id": agentId
+      },
+      body: JSON.stringify({ massType: 3 })
+    });
+  } catch {
+    return jsonError(502, "attachment_gateway_unavailable", "\u56FE\u7247\u4E0A\u4F20\u51ED\u8BC1\u670D\u52A1\u4E0D\u53EF\u7528");
+  }
+  const payload = await response.json().catch(() => void 0);
+  const massToken = payload?.data?.massToken;
+  if (!response.ok || payload?.success !== true || typeof massToken !== "string" || !massToken.trim()) {
+    const message = typeof payload?.errorMessage === "string" ? payload.errorMessage : `\u56FE\u7247\u4E0A\u4F20\u51ED\u8BC1\u670D\u52A1\u8FD4\u56DE\u5F02\u5E38\uFF08${response.status}\uFF09`;
+    return jsonError(response.ok ? 502 : response.status >= 500 ? 502 : response.status, "attachment_upload_token_failed", message);
+  }
+  return {
+    status: 200,
+    body: { operation: ATTACHMENT_CREATE_UPLOAD_TOKEN_OPERATION, massToken }
+  };
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/handler/chatRequest.js
+function guardChatRequest(method, bodyJSON, logCtx) {
+  const log = (...a) => logCtx?.log?.("[chat]", ...a);
+  const logError = (...a) => logCtx?.error?.("[chat]", ...a);
+  log("\u6536\u5230\u8BF7\u6C42, method=", method);
+  if (method !== "POST") {
+    return jsonError(405, "method_not_allowed", "\u4EC5\u652F\u6301 POST");
+  }
+  let request;
+  try {
+    request = parseConversationRunRequest(bodyJSON);
+  } catch (err) {
+    const message = err instanceof ConversationProtocolValidationError ? err.issues.join("; ") : "\u8BF7\u6C42\u4F53\u65E0\u6CD5\u89E3\u6790\u4E3A ConversationRunRequest";
+    logError("\u8BF7\u6C42\u89E3\u6790\u5931\u8D25:", message);
+    return jsonError(400, "protocol_invalid", message);
+  }
+  log("\u8BF7\u6C42\u89E3\u6790\u6210\u529F, threadId=", request.threadId, "runId=", request.runId);
+  return request;
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/conversationHistoryStore.js
+import { randomUUID } from "node:crypto";
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/conversationSearchStore.js
+import { createHash } from "node:crypto";
+var SEARCH_MESSAGE_SEGMENT_LENGTH = 4096;
+var SEARCH_MESSAGE_SEGMENT_OVERLAP = 63;
+var SEARCH_QUERY_BATCH_LIMIT = 50;
+var SEARCH_SNIPPET_LENGTH = 120;
+var CJK_KEYWORD_PATTERN = /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/u;
+async function indexConversationSearchMessages(databases, config, messages, ownerId = "anonymous") {
+  for (const message of messages) {
+    const content = normalizeSearchContent(message.content);
+    if (!content)
+      continue;
+    const segments = splitSearchContent(content);
+    for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex += 1) {
+      const segment = segments[segmentIndex];
+      if (!segment)
+        continue;
+      const data = {
+        ownerId,
+        agentId: message.agentId,
+        historyVersion: CONVERSATION_HISTORY_VERSION,
+        threadId: message.threadId,
+        runId: message.runId,
+        itemId: message.itemId,
+        role: message.role,
+        content: segment,
+        segmentIndex,
+        createdAt: message.createdAt,
+        sequence: message.sequence
+      };
+      const documentId = createSearchDocumentId(ownerId, message, segmentIndex);
+      try {
+        await databases.createDocument(config.databaseId, config.tableId, documentId, data);
+      } catch (error) {
+        if (!isConflict(error))
+          throw error;
+        await databases.updateDocument(config.databaseId, config.tableId, documentId, data);
+      }
+    }
+  }
+}
+async function searchConversationMessages(databases, config, agentId, keyword, cursor, limit, ownerId = "anonymous") {
+  const normalizedKeyword = keyword.trim();
+  const decodedCursor = decodeSearchCursor(cursor);
+  const items = [];
+  const emittedItemIds = /* @__PURE__ */ new Set();
+  if (decodedCursor.boundaryItemId) {
+    emittedItemIds.add(decodedCursor.boundaryItemId);
+  }
+  let documentCursor = decodedCursor.documentId || void 0;
+  let lastScannedDocumentId;
+  let boundaryItemId;
+  let hasMore = false;
+  while (items.length < limit) {
+    const queries = [
+      Query.equal("ownerId", ownerId),
+      Query.equal("agentId", agentId),
+      Query.equal("historyVersion", CONVERSATION_HISTORY_VERSION),
+      // AppBase 当前全文分词器会把连续中文整段视为单个 token，例如索引内容
+      // “天气搜索部署验证成功”时 Query.search(content, "天气") 无法命中。中文
+      // 关键词改用 contains 保证子串语义；英文等有明确分词边界的内容仍走全文索引。
+      CJK_KEYWORD_PATTERN.test(normalizedKeyword) ? Query.contains("content", normalizedKeyword) : Query.search("content", normalizedKeyword),
+      Query.orderDesc("createdAt"),
+      Query.orderDesc("sequence"),
+      Query.orderAsc("itemId"),
+      Query.orderAsc("segmentIndex"),
+      Query.limit(SEARCH_QUERY_BATCH_LIMIT + 1)
+    ];
+    if (documentCursor)
+      queries.push(Query.cursorAfter(documentCursor));
+    const result = await databases.listDocuments(config.databaseId, config.tableId, queries);
+    const rows = result.documents;
+    const scanRows = rows.slice(0, SEARCH_QUERY_BATCH_LIMIT);
+    hasMore = rows.length > SEARCH_QUERY_BATCH_LIMIT;
+    for (const row of scanRows) {
+      lastScannedDocumentId = row.$id;
+      const itemId = readString(row.itemId);
+      if (!itemId || emittedItemIds.has(itemId))
+        continue;
+      const hit = readSearchHit(row, normalizedKeyword);
+      if (!hit)
+        continue;
+      emittedItemIds.add(itemId);
+      items.push(hit);
+      boundaryItemId = itemId;
+      if (items.length >= limit) {
+        hasMore = true;
+        break;
+      }
+    }
+    if (items.length >= limit || !hasMore || !lastScannedDocumentId)
+      break;
+    documentCursor = lastScannedDocumentId;
+  }
+  return {
+    items,
+    nextCursor: hasMore && lastScannedDocumentId ? encodeSearchCursor({
+      documentId: lastScannedDocumentId,
+      boundaryItemId
+    }) : void 0
+  };
+}
+function splitSearchContent(content) {
+  if (content.length <= SEARCH_MESSAGE_SEGMENT_LENGTH)
+    return [content];
+  const step = SEARCH_MESSAGE_SEGMENT_LENGTH - SEARCH_MESSAGE_SEGMENT_OVERLAP;
+  const segments = [];
+  for (let start = 0; start < content.length; start += step) {
+    segments.push(content.slice(start, start + SEARCH_MESSAGE_SEGMENT_LENGTH));
+    if (start + SEARCH_MESSAGE_SEGMENT_LENGTH >= content.length)
+      break;
+  }
+  return segments;
+}
+function readSearchHit(row, keyword) {
+  const threadId = readString(row.threadId);
+  const runId = readString(row.runId);
+  const itemId = readString(row.itemId);
+  const role = row.role === "user" || row.role === "assistant" ? row.role : void 0;
+  const content = readString(row.content);
+  const createdAt = readNonNegativeInteger(row.createdAt);
+  if (!threadId || !runId || !itemId || !role || !content)
+    return void 0;
+  const { snippet, highlightRanges } = createSearchSnippet(content, keyword);
+  return { threadId, runId, itemId, role, snippet, highlightRanges, createdAt };
+}
+function createSearchSnippet(content, keyword) {
+  const normalizedContent = normalizeSearchContent(content);
+  const lowerContent = normalizedContent.toLowerCase();
+  const lowerKeyword = keyword.toLowerCase();
+  const firstMatch = lowerContent.indexOf(lowerKeyword);
+  const contentStart = firstMatch < 0 ? 0 : Math.max(0, Math.min(firstMatch - 40, normalizedContent.length - SEARCH_SNIPPET_LENGTH));
+  const rawSnippet = normalizedContent.slice(contentStart, contentStart + SEARCH_SNIPPET_LENGTH);
+  const prefix = contentStart > 0 ? "\u2026" : "";
+  const suffix = contentStart + rawSnippet.length < normalizedContent.length ? "\u2026" : "";
+  const snippet = `${prefix}${rawSnippet}${suffix}`;
+  const highlightRanges = [];
+  if (lowerKeyword) {
+    const lowerSnippet = rawSnippet.toLowerCase();
+    let from = 0;
+    while (from < lowerSnippet.length) {
+      const start = lowerSnippet.indexOf(lowerKeyword, from);
+      if (start < 0)
+        break;
+      highlightRanges.push({
+        start: prefix.length + start,
+        length: keyword.length
+      });
+      from = start + Math.max(1, lowerKeyword.length);
+    }
+  }
+  return { snippet, highlightRanges };
+}
+function normalizeSearchContent(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function createSearchDocumentId(ownerId, message, segmentIndex) {
+  return createHash("sha256").update([
+    ownerId,
+    message.agentId,
+    message.threadId,
+    message.runId,
+    message.itemId,
+    String(segmentIndex)
+  ].join("\0")).digest("hex").slice(0, 36);
+}
+function encodeSearchCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeSearchCursor(value) {
+  if (!value)
+    return { documentId: "" };
+  try {
+    const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    if (typeof parsed.documentId !== "string" || !parsed.documentId) {
+      throw new Error("missing documentId");
+    }
+    return {
+      documentId: parsed.documentId,
+      boundaryItemId: typeof parsed.boundaryItemId === "string" ? parsed.boundaryItemId : void 0
+    };
+  } catch {
+    throw new Error("\u641C\u7D22 cursor \u65E0\u6548");
+  }
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function readNonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : 0;
+}
+function isConflict(error) {
+  const value = error;
+  return value?.code === 409 || /conflict|already exists/i.test(value?.message ?? "");
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/rowSecurity.js
+function rowPermissions(ownerId) {
+  if (!ownerId)
+    return void 0;
+  const role = `user:${ownerId}`;
+  return [`read("${role}")`, `update("${role}")`, `delete("${role}")`];
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/conversationHistoryStore.js
+var DEFAULT_HISTORY_OWNER_ID = "anonymous";
+var RUN_CHUNK_QUERY_LIMIT = 5e3;
+var ConversationHistoryNotFoundError = class extends Error {
+  constructor(message = "\u4F1A\u8BDD\u4E0D\u5B58\u5728\u6216\u4E0D\u5C5E\u4E8E\u5F53\u524D Agent") {
+    super(message);
+    this.name = "ConversationHistoryNotFoundError";
+  }
+};
+function resolveConversationHistoryStorage(env = process.env) {
+  return {
+    runDatabaseId: requiredEnv(env, "RUN_DATABASE_ID"),
+    runTableId: requiredEnv(env, "RUN_TABLE_ID"),
+    sessionDatabaseId: requiredEnv(env, "SESSION_DATABASE_ID"),
+    sessionTableId: requiredEnv(env, "SESSION_TABLE_ID"),
+    runIndexDatabaseId: requiredEnv(env, "RUN_INDEX_DATABASE_ID"),
+    runIndexTableId: requiredEnv(env, "RUN_INDEX_TABLE_ID"),
+    searchDatabaseId: requiredEnv(env, "SEARCH_DATABASE_ID"),
+    searchTableId: requiredEnv(env, "SEARCH_TABLE_ID")
+  };
+}
+function createConversationHistoryStore(databases, config, ownerId = DEFAULT_HISTORY_OWNER_ID) {
+  return {
+    async beginRun(request, agentId) {
+      const startedAt = Date.now();
+      const existingSession = await readDocument(databases, config.sessionDatabaseId, config.sessionTableId, request.threadId);
+      if (existingSession && !isOwnedConversation(existingSession, ownerId, agentId)) {
+        throw new ConversationHistoryNotFoundError();
+      }
+      const existingRun = await readDocument(databases, config.runIndexDatabaseId, config.runIndexTableId, request.runId);
+      if (existingRun && (existingRun.ownerId !== ownerId || existingRun.agentId !== agentId || existingRun.threadId !== request.threadId)) {
+        throw new ConversationHistoryNotFoundError("Run \u4E0D\u5C5E\u4E8E\u5F53\u524D\u7528\u6237");
+      }
+      await upsertDocument(databases, config.runIndexDatabaseId, config.runIndexTableId, request.runId, {
+        runId: request.runId,
+        threadId: request.threadId,
+        ownerId,
+        agentId,
+        historyVersion: CONVERSATION_HISTORY_VERSION,
+        requestJson: JSON.stringify(createStoredHistoryRequest(request)),
+        status: "running",
+        startedAt,
+        totalChunks: 0,
+        followUpQuestionsJson: null
+      }, rowPermissions(ownerId));
+      const copy = deriveConversationCopy(request);
+      const existingRunCount = readNonNegativeInteger2(existingSession?.runCount);
+      const sessionAlreadyContainsRun = existingSession?.lastRunId === request.runId;
+      const metadata = {
+        sessionId: request.threadId,
+        turns: readStringArray(existingSession?.turns),
+        ownerId,
+        agentId,
+        historyVersion: CONVERSATION_HISTORY_VERSION,
+        title: existingRunCount > 0 ? readNonEmptyString(existingSession?.title) ?? copy.title : copy.title,
+        preview: copy.preview,
+        runCount: sessionAlreadyContainsRun ? existingRunCount : existingRunCount + 1,
+        createdAt: readNonNegativeInteger2(existingSession?.createdAt) || startedAt,
+        lastMessageAt: startedAt,
+        lastActiveAt: startedAt,
+        lastRunId: request.runId,
+        lastRunStatus: "running"
+      };
+      await upsertDocument(databases, config.sessionDatabaseId, config.sessionTableId, request.threadId, metadata);
+    },
+    async completeRun(completion) {
+      const completedAt = completion.completedAt ?? Date.now();
+      const run = await readDocument(databases, config.runIndexDatabaseId, config.runIndexTableId, completion.runId);
+      if (!run || run.ownerId !== ownerId || run.threadId !== completion.threadId) {
+        throw new ConversationHistoryNotFoundError("Run \u4E0D\u5C5E\u4E8E\u5F53\u524D\u7528\u6237");
+      }
+      const persistedStatus = readRunStatus(run.status);
+      const status = persistedStatus === "cancelling" || persistedStatus === "cancelled" ? "cancelled" : completion.status;
+      await databases.updateDocument(config.runIndexDatabaseId, config.runIndexTableId, completion.runId, {
+        status,
+        completedAt,
+        totalChunks: completion.totalChunks,
+        ...status === "cancelled" ? { cancelledAt: completedAt } : {}
+      });
+      const session = await readDocument(databases, config.sessionDatabaseId, config.sessionTableId, completion.threadId);
+      if (session?.ownerId === ownerId && session.lastRunId === completion.runId) {
+        await databases.updateDocument(config.sessionDatabaseId, config.sessionTableId, completion.threadId, { lastRunStatus: status });
+      }
+    },
+    async saveFollowUpQuestions(runId, threadId, value) {
+      const normalized = parseConversationFollowUpQuestions(value);
+      if (!normalized?.questions.length)
+        return;
+      const run = await readDocument(databases, config.runIndexDatabaseId, config.runIndexTableId, runId);
+      if (!run || run.ownerId !== ownerId || run.threadId !== threadId || readRunStatus(run.status) !== "done") {
+        throw new ConversationHistoryNotFoundError("Run \u4E0D\u5C5E\u4E8E\u5F53\u524D\u7528\u6237\u6216\u5C1A\u672A\u6210\u529F\u7ED3\u675F");
+      }
+      await databases.updateDocument(config.runIndexDatabaseId, config.runIndexTableId, runId, { followUpQuestionsJson: JSON.stringify(normalized) });
+    },
+    async getRecentFollowUpQuestionContext(agentId, threadId, currentRunId, limit) {
+      const boundedLimit = Math.max(0, Math.min(limit, 2));
+      if (boundedLimit === 0)
+        return [];
+      const currentRun = await readDocument(databases, config.runIndexDatabaseId, config.runIndexTableId, currentRunId);
+      if (!currentRun || currentRun.ownerId !== ownerId || currentRun.agentId !== agentId || currentRun.threadId !== threadId) {
+        throw new ConversationHistoryNotFoundError("Run \u4E0D\u5C5E\u4E8E\u5F53\u524D\u7528\u6237");
+      }
+      const result = await databases.listDocuments(config.runIndexDatabaseId, config.runIndexTableId, [
+        Query.equal("ownerId", ownerId),
+        Query.equal("agentId", agentId),
+        Query.equal("threadId", threadId),
+        Query.equal("historyVersion", CONVERSATION_HISTORY_VERSION),
+        Query.orderDesc("startedAt"),
+        Query.limit(25)
+      ]);
+      const entries = [];
+      for (const row of result.documents) {
+        if (row.runId === currentRunId || readRunStatus(row.status) !== "done") {
+          continue;
+        }
+        if (row.blockedQuestion === true || row.blockedAnswer === true)
+          continue;
+        const userMessage = readStoredRunUserMessage(row.requestJson);
+        if (!userMessage)
+          continue;
+        const followUpQuestions = readStoredFollowUpQuestions(row.followUpQuestionsJson)?.questions.map((question) => question.prompt) ?? [];
+        entries.push({ userMessage, followUpQuestions });
+        if (entries.length === boundedLimit)
+          break;
+      }
+      const chronological = [];
+      for (let index = entries.length - 1; index >= 0; index -= 1) {
+        chronological.push(entries[index]);
+      }
+      return chronological;
+    },
+    async requestRunCancellation(agentId, runId) {
+      const run = await readDocument(databases, config.runIndexDatabaseId, config.runIndexTableId, runId);
+      if (!run || run.ownerId !== ownerId || run.agentId !== agentId) {
+        return "not_found";
+      }
+      const status = readRunStatus(run.status);
+      if (status === "done" || status === "error" || status === "cancelled") {
+        return status;
+      }
+      if (status !== "cancelling") {
+        await databases.updateDocument(config.runIndexDatabaseId, config.runIndexTableId, runId, { status: "cancelling", cancelRequestedAt: Date.now() });
+      }
+      return "cancelling";
+    },
+    async isRunCancellationRequested(agentId, runId) {
+      const run = await readDocument(databases, config.runIndexDatabaseId, config.runIndexTableId, runId);
+      if (!run || run.ownerId !== ownerId || run.agentId !== agentId) {
+        return false;
+      }
+      const status = readRunStatus(run.status);
+      return status === "cancelling" || status === "cancelled" || readNonNegativeInteger2(run.cancelRequestedAt) > 0;
+    },
+    async setRunBlocked(params) {
+      const existing = await readDocument(databases, config.runIndexDatabaseId, config.runIndexTableId, params.runId);
+      if (!existing) {
+        throw new ConversationHistoryNotFoundError("Run \u4E0D\u5B58\u5728");
+      }
+      const prevBlockedQuestion = existing.blockedQuestion === true;
+      const prevBlockedAnswer = existing.blockedAnswer === true;
+      const prevQuestionReplacement = readNonEmptyString(existing.questionReplacement);
+      const prevAnswerReplacement = readNonEmptyString(existing.answerReplacement);
+      const blockedQuestion = params.blockQuestion ?? prevBlockedQuestion;
+      const blockedAnswer = params.blockAnswer ?? prevBlockedAnswer;
+      const questionReplacement = params.blockQuestion === true ? params.questionReplacement ?? "" : params.blockQuestion === false ? null : prevQuestionReplacement ?? null;
+      const answerReplacement = params.blockAnswer === true ? params.answerReplacement ?? "" : params.blockAnswer === false ? null : prevAnswerReplacement ?? null;
+      const blockedAt = Date.now();
+      const blockedBy = readNonEmptyString(params.blockedBy);
+      await databases.updateDocument(config.runIndexDatabaseId, config.runIndexTableId, params.runId, {
+        blockedQuestion,
+        blockedAnswer,
+        questionReplacement,
+        answerReplacement,
+        blockedAt,
+        blockedBy: blockedBy ?? null
+      });
+      return {
+        runId: params.runId,
+        threadId: readNonEmptyString(existing.threadId) ?? params.threadId,
+        blockedQuestion,
+        blockedAnswer,
+        questionReplacement: readNonEmptyString(questionReplacement),
+        answerReplacement: readNonEmptyString(answerReplacement),
+        blockedAt,
+        blockedBy
+      };
+    },
+    async bootstrap(agentId, limit) {
+      const page = await listConversationPage(databases, config, agentId, ownerId, void 0, limit);
+      let activeConversation = await findActiveSession(databases, config, agentId, ownerId);
+      if (!activeConversation && page.items.length) {
+        const fallbackThreadId = page.items[0].threadId;
+        await activateSessionDocument(databases, config, fallbackThreadId);
+        activeConversation = await readDocument(databases, config.sessionDatabaseId, config.sessionTableId, fallbackThreadId);
+      }
+      const activeThreadId = readNonEmptyString(activeConversation?.sessionId) ?? await createSessionDocument(databases, config, agentId, ownerId);
+      return {
+        activeThreadId,
+        activeConversationExists: readNonNegativeInteger2(activeConversation?.runCount) > 0,
+        conversations: page.items,
+        nextCursor: page.nextCursor
+      };
+    },
+    listConversations: (agentId, cursor, limit) => listConversationPage(databases, config, agentId, ownerId, cursor, limit),
+    async getConversationRuns(agentId, threadId, cursor, limit, direction = "older") {
+      await assertConversationExists(databases, config, agentId, ownerId, threadId);
+      const queries = [
+        Query.equal("ownerId", ownerId),
+        Query.equal("agentId", agentId),
+        Query.equal("threadId", threadId),
+        Query.equal("historyVersion", CONVERSATION_HISTORY_VERSION),
+        direction === "newer" ? Query.orderAsc("startedAt") : Query.orderDesc("startedAt"),
+        Query.limit(limit + 1)
+      ];
+      if (cursor)
+        queries.push(Query.cursorAfter(cursor));
+      const result = await databases.listDocuments(config.runIndexDatabaseId, config.runIndexTableId, queries);
+      const pageRows = result.documents.slice(0, limit);
+      const runs = await Promise.all(pageRows.map((row) => readConversationRun(databases, config, row)));
+      return {
+        items: runs,
+        nextCursor: result.documents.length > limit ? readNonEmptyString(pageRows.at(-1)?.$id) : void 0
+      };
+    },
+    async getConversationRunWindow(agentId, threadId, runId, beforeLimit, afterLimit) {
+      await assertConversationExists(databases, config, agentId, ownerId, threadId);
+      const anchor = await readDocument(databases, config.runIndexDatabaseId, config.runIndexTableId, runId);
+      if (!anchor || anchor.threadId !== threadId || anchor.agentId !== agentId || anchor.ownerId !== ownerId || anchor.historyVersion !== CONVERSATION_HISTORY_VERSION) {
+        throw new ConversationHistoryNotFoundError("\u76EE\u6807\u5386\u53F2\u6D88\u606F\u4E0D\u5B58\u5728");
+      }
+      const baseQueries = [
+        Query.equal("ownerId", ownerId),
+        Query.equal("agentId", agentId),
+        Query.equal("threadId", threadId),
+        Query.equal("historyVersion", CONVERSATION_HISTORY_VERSION)
+      ];
+      const [olderResult, newerResult] = await Promise.all([
+        databases.listDocuments(config.runIndexDatabaseId, config.runIndexTableId, [
+          ...baseQueries,
+          Query.orderDesc("startedAt"),
+          Query.cursorAfter(runId),
+          Query.limit(beforeLimit + 1)
+        ]),
+        databases.listDocuments(config.runIndexDatabaseId, config.runIndexTableId, [
+          ...baseQueries,
+          Query.orderAsc("startedAt"),
+          Query.cursorAfter(runId),
+          Query.limit(afterLimit + 1)
+        ])
+      ]);
+      const olderRows = olderResult.documents.slice(0, beforeLimit);
+      const newerRows = newerResult.documents.slice(0, afterLimit);
+      const rows = [...olderRows, anchor, ...newerRows];
+      return {
+        items: await Promise.all(rows.map((row) => readConversationRun(databases, config, row))),
+        olderCursor: olderResult.documents.length > beforeLimit ? readNonEmptyString(olderRows.at(-1)?.$id) : void 0,
+        newerCursor: newerResult.documents.length > afterLimit ? readNonEmptyString(newerRows.at(-1)?.$id) : void 0
+      };
+    },
+    indexSearchMessages: (messages) => indexConversationSearchMessages(databases, { databaseId: config.searchDatabaseId, tableId: config.searchTableId }, messages, ownerId),
+    searchConversationMessages: (agentId, keyword, cursor, limit) => searchConversationMessages(databases, { databaseId: config.searchDatabaseId, tableId: config.searchTableId }, agentId, keyword, cursor, limit, ownerId),
+    createSession: (agentId) => createSessionDocument(databases, config, agentId, ownerId),
+    async activateConversation(agentId, threadId) {
+      await assertConversationExists(databases, config, agentId, ownerId, threadId);
+      await activateSessionDocument(databases, config, threadId);
+    }
+  };
+}
+async function listConversationPage(databases, config, agentId, ownerId, cursor, limit) {
+  const queries = [
+    Query.equal("ownerId", ownerId),
+    Query.equal("agentId", agentId),
+    Query.equal("historyVersion", CONVERSATION_HISTORY_VERSION),
+    Query.greaterThan("runCount", 0),
+    Query.orderDesc("lastMessageAt"),
+    Query.limit(limit + 1)
+  ];
+  if (cursor)
+    queries.push(Query.cursorAfter(cursor));
+  const result = await databases.listDocuments(config.sessionDatabaseId, config.sessionTableId, queries);
+  const rows = result.documents.slice(0, limit);
+  return {
+    items: rows.map(readConversationSummary),
+    nextCursor: result.documents.length > limit ? readNonEmptyString(rows.at(-1)?.$id) : void 0
+  };
+}
+async function readConversationRun(databases, config, row) {
+  const runId = requireRowString(row, "runId");
+  const threadId = requireRowString(row, "threadId");
+  const requestJson = requireRowString(row, "requestJson");
+  const chunks = await databases.listDocuments(config.runDatabaseId, config.runTableId, [
+    Query.equal("runId", runId),
+    Query.orderAsc("seqIndex"),
+    Query.limit(RUN_CHUNK_QUERY_LIMIT)
+  ]);
+  const chunkRows = chunks.documents;
+  const status = readRunStatus(row.status);
+  const expectedChunks = readNonNegativeInteger2(row.totalChunks);
+  if (chunks.total > chunkRows.length || status !== "running" && expectedChunks > chunkRows.length) {
+    throw new Error(`run ${runId} \u5206\u7247\u4E0D\u5B8C\u6574\uFF0C\u5DF2\u8BFB\u53D6 ${chunkRows.length} / ${Math.max(chunks.total, expectedChunks)}`);
+  }
+  return {
+    runId,
+    threadId,
+    request: parseConversationRunRequest(JSON.parse(requestJson)),
+    lines: chunkRows.flatMap((chunk) => readStringArray(chunk.lines)),
+    status,
+    startedAt: readNonNegativeInteger2(row.startedAt),
+    completedAt: row.completedAt === null || row.completedAt === void 0 ? void 0 : readNonNegativeInteger2(row.completedAt),
+    blockedQuestion: row.blockedQuestion === true,
+    blockedAnswer: row.blockedAnswer === true,
+    questionReplacement: readNonEmptyString(row.questionReplacement),
+    answerReplacement: readNonEmptyString(row.answerReplacement),
+    blockedAt: row.blockedAt === null || row.blockedAt === void 0 ? void 0 : readNonNegativeInteger2(row.blockedAt),
+    blockedBy: readNonEmptyString(row.blockedBy),
+    followUpQuestions: readStoredFollowUpQuestions(row.followUpQuestionsJson)
+  };
+}
+function readStoredFollowUpQuestions(value) {
+  if (typeof value !== "string" || !value.trim())
+    return void 0;
+  try {
+    const parsed = parseConversationFollowUpQuestions(JSON.parse(value));
+    return parsed?.questions.length ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readStoredRunUserMessage(value) {
+  if (typeof value !== "string" || !value.trim())
+    return void 0;
+  try {
+    const request = parseConversationRunRequest(JSON.parse(value));
+    for (let index = request.messages.length - 1; index >= 0; index -= 1) {
+      const message = request.messages[index];
+      if (message.role !== "user")
+        continue;
+      return typeof message.content === "string" ? readNonEmptyString(message.content.replace(/\s+/gu, " ")) : void 0;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readConversationSummary(row) {
+  return {
+    threadId: requireRowString(row, "sessionId"),
+    title: readNonEmptyString(row.title) ?? "\u65B0\u4F1A\u8BDD",
+    preview: typeof row.preview === "string" ? row.preview : "",
+    runCount: readNonNegativeInteger2(row.runCount),
+    createdAt: readNonNegativeInteger2(row.createdAt),
+    updatedAt: readNonNegativeInteger2(row.lastMessageAt),
+    lastRunStatus: readRunStatus(row.lastRunStatus)
+  };
+}
+async function assertConversationExists(databases, config, agentId, ownerId, threadId) {
+  const row = await readDocument(databases, config.sessionDatabaseId, config.sessionTableId, threadId);
+  if (!isOwnedConversation(row, ownerId, agentId)) {
+    throw new ConversationHistoryNotFoundError();
+  }
+}
+async function findActiveSession(databases, config, agentId, ownerId) {
+  const result = await databases.listDocuments(config.sessionDatabaseId, config.sessionTableId, [
+    Query.equal("ownerId", ownerId),
+    Query.equal("agentId", agentId),
+    Query.equal("historyVersion", CONVERSATION_HISTORY_VERSION),
+    Query.orderDesc("lastActiveAt"),
+    Query.limit(1)
+  ]);
+  return result.documents[0];
+}
+async function createSessionDocument(databases, config, agentId, ownerId) {
+  const threadId = createConversationThreadId();
+  const now = Date.now();
+  await databases.createDocument(config.sessionDatabaseId, config.sessionTableId, threadId, {
+    sessionId: threadId,
+    turns: [],
+    ownerId,
+    agentId,
+    historyVersion: CONVERSATION_HISTORY_VERSION,
+    title: "\u65B0\u4F1A\u8BDD",
+    preview: "",
+    runCount: 0,
+    createdAt: now,
+    lastActiveAt: now
+  });
+  return threadId;
+}
+function isOwnedConversation(row, ownerId, agentId) {
+  return Boolean(row && row.ownerId === ownerId && row.agentId === agentId && row.historyVersion === CONVERSATION_HISTORY_VERSION);
+}
+async function activateSessionDocument(databases, config, threadId) {
+  await databases.updateDocument(config.sessionDatabaseId, config.sessionTableId, threadId, { lastActiveAt: Date.now() });
+}
+async function upsertDocument(databases, databaseId, tableId, documentId, data, permissions) {
+  const existing = await readDocument(databases, databaseId, tableId, documentId);
+  if (existing) {
+    await databases.updateDocument(databaseId, tableId, documentId, data);
+  } else {
+    await databases.createDocument(databaseId, tableId, documentId, data, permissions);
+  }
+}
+async function readDocument(databases, databaseId, tableId, documentId) {
+  try {
+    return await databases.getDocument(databaseId, tableId, documentId);
+  } catch (error) {
+    if (isNotFound2(error))
+      return void 0;
+    throw error;
+  }
+}
+function deriveConversationCopy(request) {
+  const content = request.messages.at(-1)?.content;
+  let visibleText = "";
+  if (typeof content === "string") {
+    visibleText = content.trim();
+  } else if (content?.type === "a2ui.event") {
+    visibleText = content.displayText?.trim() || content.event.name;
+  }
+  if (!visibleText && request.attachments.length)
+    visibleText = "[\u56FE\u7247]";
+  if (!visibleText)
+    visibleText = "\u65B0\u4F1A\u8BDD";
+  return {
+    title: visibleText.slice(0, 40),
+    preview: visibleText.slice(0, 160)
+  };
+}
+function createStoredHistoryRequest(request) {
+  return {
+    ...request,
+    messages: request.messages.map((message) => ({ ...message })),
+    attachments: request.attachments.map((attachment) => {
+      const hasPersistentTarget = Boolean(attachment.resourceId || attachment.url);
+      return {
+        id: attachment.id,
+        resourceId: attachment.resourceId,
+        name: attachment.name,
+        mimeType: attachment.mimeType,
+        size: attachment.size,
+        url: hasPersistentTarget ? attachment.url : "appwrite://image-placeholder",
+        metadata: hasPersistentTarget ? attachment.metadata : { ...attachment.metadata, uploadPending: true }
+      };
+    }),
+    metadata: { ...request.metadata }
+  };
+}
+function createConversationThreadId() {
+  return `thread-${Date.now()}-${randomUUID().replaceAll("-", "").slice(0, 12)}`;
+}
+function readRunStatus(value) {
+  return value === "done" || value === "error" || value === "cancelling" || value === "cancelled" ? value : "running";
+}
+function readStringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function readNonNegativeInteger2(value) {
+  return Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : 0;
+}
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function requireRowString(row, field) {
+  const value = readNonEmptyString(row[field]);
+  if (!value)
+    throw new Error(`\u5386\u53F2\u6570\u636E\u7F3A\u5C11\u5B57\u6BB5 ${field}`);
+  return value;
+}
+function requiredEnv(env, name) {
+  const value = env[name]?.trim();
+  if (!value)
+    throw new Error(`${name} \u672A\u914D\u7F6E`);
+  return value;
+}
+function isNotFound2(error) {
+  if (!error)
+    return false;
+  const value = error;
+  return value.code === 404 || /not found|404/i.test(value.message ?? "");
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/handler/cancel.js
+async function runCancelConversation(method, bodyJSON, env, deps, logCtx, ownerId, appwriteApiKey) {
+  if (method !== "POST") {
+    return controlError(405, "method_not_allowed", "\u4EC5\u652F\u6301 POST");
+  }
+  let request;
+  try {
+    request = parseCancelConversationRunRequest(bodyJSON);
+  } catch (error) {
+    const message = error instanceof ConversationControlValidationError ? error.issues.join("; ") : "\u8BF7\u6C42\u4F53\u65E0\u6CD5\u89E3\u6790\u4E3A CancelConversationRunRequest";
+    return controlError(400, "control_protocol_invalid", message);
+  }
+  const protocol = deps?.protocol ?? getBakedProtocol();
+  let store = deps?.store;
+  if (!store) {
+    try {
+      const handle = createAppBaseClient(env, logCtx, appwriteApiKey);
+      store = createConversationHistoryStore(handle.databases, resolveConversationHistoryStorage(env), ownerId);
+    } catch (error) {
+      logCtx?.error?.("[cancel] \u5B58\u50A8\u914D\u7F6E\u5931\u8D25:", error);
+      return controlError(500, "cancel_storage_unconfigured", error instanceof Error ? error.message : "\u53D6\u6D88\u72B6\u6001\u5B58\u50A8\u672A\u914D\u7F6E");
+    }
+  }
+  if (!store.requestRunCancellation) {
+    return controlError(501, "cancel_unsupported", "\u5F53\u524D\u90E8\u7F72\u4E0D\u652F\u6301\u670D\u52A1\u7AEF\u53D6\u6D88");
+  }
+  try {
+    const status = await store.requestRunCancellation(protocol.agentId, request.runId);
+    const response = {
+      operation: CANCEL_CONVERSATION_RUN_OPERATION,
+      runId: request.runId,
+      accepted: status === "cancelling" || status === "cancelled",
+      status
+    };
+    return { status: 200, body: response };
+  } catch (error) {
+    logCtx?.error?.("[cancel] \u8BF7\u6C42\u6267\u884C\u5931\u8D25:", error);
+    return controlError(500, "cancel_request_failed", error instanceof Error ? error.message : "\u53D6\u6D88\u8BF7\u6C42\u6267\u884C\u5931\u8D25");
+  }
+}
+function controlError(status, code, message) {
+  return { status, body: { error: { code, message, status } } };
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/appbaseStore.js
+function createAppBaseStore(databases, databaseId, tableId, ownerId) {
+  const permissions = rowPermissions(ownerId);
+  return {
+    create: async (row) => {
+      const created = await databases.createDocument(
+        databaseId,
+        tableId,
+        "unique()",
+        // 让 AppBase 生成唯一 rowId
+        {
+          runId: row.runId,
+          threadId: row.threadId,
+          seqIndex: row.seqIndex,
+          status: row.status,
+          lines: row.lines,
+          ...ownerId ? { ownerId } : {}
+        },
+        permissions
+      );
+      return created.$id;
+    }
+  };
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/chunkSink.js
+var ChunkSink = class {
+  storage;
+  chunkSize;
+  flushIntervalMs;
+  ctx;
+  /** 已 create 的 chunk 数(含 chunk#0);下次 seqIndex = chunkCount。 */
+  chunkCount = 0;
+  pending = [];
+  firstId;
+  flushTimer;
+  operationQueue = Promise.resolve();
+  deferredError;
+  closed = false;
+  constructor(storage, ctx, options = {}) {
+    this.storage = storage;
+    this.chunkSize = options.chunkSize ?? 30;
+    this.flushIntervalMs = options.flushIntervalMs ?? 250;
+    this.ctx = ctx;
+  }
+  /** 建 chunk#0(running,空)。必须最先调用。返回 chunk#0 的 $id。 */
+  async open() {
+    await this.enqueue(async () => {
+      this.firstId = await this.createChunk(0, "running", []);
+    });
+    return this.id;
+  }
+  /** 已建立的 chunk#0 id。 */
+  get id() {
+    if (this.firstId === void 0)
+      throw new Error("ChunkSink.open() \u672A\u8C03\u7528");
+    return this.firstId;
+  }
+  /** 已 create 的 chunk 总数(含 chunk#0)。 */
+  get totalChunks() {
+    return this.chunkCount;
+  }
+  /**
+   * 喂入一段 SSE 编码文本,按行追加并按 chunkSize 切块 create。
+   * chunk 通常等于 `encodeConversationSseEvent(ev)` 的产物(以 \n\n 结尾)。
+   */
+  async writeChunk(chunk, options = {}) {
+    if (this.closed)
+      throw new Error("ChunkSink \u5DF2\u7ED3\u675F\uFF0C\u4E0D\u80FD\u7EE7\u7EED\u5199\u5165");
+    const newLines = chunk.split("\n");
+    if (newLines.length && newLines[newLines.length - 1] === "")
+      newLines.pop();
+    if (!newLines.length)
+      return;
+    await this.enqueue(async () => {
+      this.pending.push(...newLines);
+      await this.flushFullChunks();
+      if (options.flush) {
+        await this.flushPending();
+      } else {
+        this.scheduleFlush();
+      }
+    });
+  }
+  /** 终结流:把剩余 pending 作为末 chunk create,带终态 status。 */
+  async finalize(status) {
+    this.closed = true;
+    this.clearFlushTimer();
+    await this.enqueue(async () => {
+      await this.createChunk(this.chunkCount, status, this.pending);
+      this.pending = [];
+    });
+  }
+  /** 当 pending 行数 ≥ chunkSize 时,循环切出 running chunk。 */
+  async flushFullChunks() {
+    while (this.pending.length >= this.chunkSize) {
+      const lines = this.pending.splice(0, this.chunkSize);
+      await this.createChunk(this.chunkCount, "running", lines);
+    }
+    if (!this.pending.length)
+      this.clearFlushTimer();
+  }
+  /** 把不足阈值的 pending 作为 running chunk 写出。 */
+  async flushPending() {
+    this.clearFlushTimer();
+    if (!this.pending.length)
+      return;
+    const lines = [...this.pending];
+    await this.createChunk(this.chunkCount, "running", lines);
+    this.pending = [];
+  }
+  /** 从首批 pending 开始计时，不因后续 delta 重置，保证最大等待时间有上界。 */
+  scheduleFlush() {
+    if (!this.pending.length || this.flushTimer || this.closed)
+      return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = void 0;
+      void this.enqueue(async () => {
+        if (this.closed)
+          return;
+        await this.flushPending();
+      }).catch(() => void 0);
+    }, this.flushIntervalMs);
+  }
+  clearFlushTimer() {
+    if (!this.flushTimer)
+      return;
+    clearTimeout(this.flushTimer);
+    this.flushTimer = void 0;
+  }
+  /** 串行化 timer/write/finalize，保持 seqIndex 严格递增并把后台 timer 错误传给主流程。 */
+  enqueue(operation) {
+    const next = this.operationQueue.then(async () => {
+      if (this.deferredError)
+        throw this.deferredError;
+      await operation();
+    });
+    this.operationQueue = next.catch((error) => {
+      this.deferredError ??= error;
+    });
+    return next;
+  }
+  /** create 一个 chunk;seqIndex 取当前 chunkCount,create 后 chunkCount 自增。 */
+  async createChunk(seqIndex, status, lines) {
+    const id = await this.storage.create({
+      runId: this.ctx.runId,
+      threadId: this.ctx.threadId,
+      seqIndex,
+      status,
+      lines
+    });
+    this.chunkCount += 1;
+    return id;
+  }
+};
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/ports/appbaseSessionLease.js
+import { createHash as createHash2 } from "node:crypto";
+var DEFAULT_LEASE_TTL_MS = 20 * 60 * 1e3;
+var TRANSACTION_TTL_SECONDS = 60;
+function createSessionLease(persistence, options = {}) {
+  const ttlMs = options.ttlMs ?? DEFAULT_LEASE_TTL_MS;
+  const now = options.now ?? Date.now;
+  return {
+    acquire: async (threadId, ownerId) => {
+      const leaseId = createLeaseId(threadId);
+      if (await tryCreate(persistence, leaseId, ownerId))
+        return true;
+      const current = await persistence.read(leaseId);
+      if (current && now() - current.updatedAt <= ttlMs)
+        return false;
+      if (!current)
+        return tryCreate(persistence, leaseId, ownerId);
+      return persistence.replaceIfOwner(leaseId, current.ownerId, ownerId);
+    },
+    release: async (threadId, ownerId) => {
+      const leaseId = createLeaseId(threadId);
+      await persistence.deleteIfOwner(leaseId, ownerId);
+    }
+  };
+}
+function createAppBaseSessionLease(databases, databaseId, tableId, appbaseUserId, options = {}) {
+  const permissions = rowPermissions(appbaseUserId);
+  const persistence = {
+    create: async (leaseId, ownerId) => {
+      await databases.createDocument(databaseId, tableId, leaseId, {
+        sessionId: leaseId,
+        turns: [ownerId],
+        ...appbaseUserId ? { ownerId: appbaseUserId } : {}
+      }, permissions);
+    },
+    read: async (leaseId) => {
+      return readLeaseRecord(databases, databaseId, tableId, leaseId);
+    },
+    replaceIfOwner: async (leaseId, expectedOwnerId, nextOwnerId) => {
+      return mutateIfOwner(databases, databaseId, tableId, leaseId, expectedOwnerId, async (transactionId) => {
+        await databases.updateDocument({
+          databaseId,
+          collectionId: tableId,
+          documentId: leaseId,
+          data: { turns: [nextOwnerId] },
+          transactionId
+        });
+      });
+    },
+    deleteIfOwner: async (leaseId, expectedOwnerId) => {
+      return mutateIfOwner(databases, databaseId, tableId, leaseId, expectedOwnerId, async (transactionId) => {
+        await databases.deleteDocument({
+          databaseId,
+          collectionId: tableId,
+          documentId: leaseId,
+          transactionId
+        });
+      });
+    }
+  };
+  return createSessionLease(persistence, options);
+}
+async function tryCreate(persistence, leaseId, ownerId) {
+  try {
+    await persistence.create(leaseId, ownerId);
+    return true;
+  } catch (err) {
+    if (isConflict2(err))
+      return false;
+    throw err;
+  }
+}
+function createLeaseId(threadId) {
+  const digest = createHash2("sha256").update(threadId).digest("hex");
+  return `lease_${digest.slice(0, 30)}`;
+}
+async function mutateIfOwner(databases, databaseId, tableId, leaseId, expectedOwnerId, stageMutation) {
+  const transaction = await databases.createTransaction({
+    ttl: TRANSACTION_TTL_SECONDS
+  });
+  try {
+    const current = await readLeaseRecord(databases, databaseId, tableId, leaseId, transaction.$id);
+    if (!current || current.ownerId !== expectedOwnerId) {
+      await rollbackTransaction(databases, transaction.$id);
+      return false;
+    }
+    await stageMutation(transaction.$id);
+    await databases.updateTransaction({
+      transactionId: transaction.$id,
+      commit: true
+    });
+    return true;
+  } catch (err) {
+    await rollbackTransaction(databases, transaction.$id);
+    if (isConflict2(err) || isNotFound3(err))
+      return false;
+    throw err;
+  }
+}
+async function readLeaseRecord(databases, databaseId, tableId, leaseId, transactionId) {
+  try {
+    const doc = await databases.getDocument({
+      databaseId,
+      collectionId: tableId,
+      documentId: leaseId,
+      transactionId
+    });
+    const raw = doc;
+    const ownerId = Array.isArray(raw.turns) && typeof raw.turns[0] === "string" ? raw.turns[0] : void 0;
+    if (!ownerId)
+      return void 0;
+    const timestamp = typeof raw.$updatedAt === "string" ? raw.$updatedAt : raw.$createdAt;
+    const parsedUpdatedAt = typeof timestamp === "string" ? Date.parse(timestamp) : Number.NaN;
+    return {
+      ownerId,
+      updatedAt: Number.isFinite(parsedUpdatedAt) ? parsedUpdatedAt : Date.now()
+    };
+  } catch (err) {
+    if (isNotFound3(err))
+      return void 0;
+    throw err;
+  }
+}
+async function rollbackTransaction(databases, transactionId) {
+  await databases.updateTransaction({ transactionId, rollback: true }).catch(() => void 0);
+}
+function isConflict2(err) {
+  if (!err)
+    return false;
+  const value = err;
+  return value.code === 409 || /already exists|conflict|duplicate|409/i.test(value.message ?? "");
+}
+function isNotFound3(err) {
+  if (!err)
+    return false;
+  const value = err;
+  return value.code === 404 || /not found|404/i.test(value.message ?? "");
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/handler/history.js
+async function runHistory(method, bodyJSON, env, deps, logCtx, historyOwnerId, appwriteApiKey) {
+  if (method !== "POST") {
+    return historyError(405, "method_not_allowed", "\u4EC5\u652F\u6301 POST");
+  }
+  let request;
+  try {
+    request = parseConversationHistoryRequest(bodyJSON);
+  } catch (error) {
+    const message = error instanceof ConversationHistoryValidationError ? error.issues.join("; ") : "\u8BF7\u6C42\u4F53\u65E0\u6CD5\u89E3\u6790\u4E3A ConversationHistoryRequest";
+    return historyError(400, "history_protocol_invalid", message);
+  }
+  const protocol = deps?.protocol ?? getBakedProtocol();
+  if (request.agentId !== protocol.agentId) {
+    return historyError(403, "agent_mismatch", "\u8BF7\u6C42 Agent \u4E0E\u90E8\u7F72\u7248\u672C\u4E0D\u5339\u914D");
+  }
+  let store = deps?.store;
+  if (!store) {
+    try {
+      const handle = createAppBaseClient(env, logCtx, appwriteApiKey);
+      store = createConversationHistoryStore(handle.databases, resolveConversationHistoryStorage(env), historyOwnerId);
+    } catch (error) {
+      logCtx?.error?.("[history] \u5B58\u50A8\u914D\u7F6E\u5931\u8D25:", error);
+      return historyError(500, "history_storage_unconfigured", error instanceof Error ? error.message : "\u4F1A\u8BDD\u5386\u53F2\u5B58\u50A8\u672A\u914D\u7F6E");
+    }
+  }
+  try {
+    switch (request.operation) {
+      case "bootstrap": {
+        const result = await store.bootstrap(request.agentId, request.limit ?? DEFAULT_CONVERSATION_LIST_LIMIT);
+        return {
+          status: 200,
+          body: { operation: request.operation, ...result }
+        };
+      }
+      case "listConversations": {
+        const page = await store.listConversations(request.agentId, request.cursor, request.limit ?? DEFAULT_CONVERSATION_LIST_LIMIT);
+        return {
+          status: 200,
+          body: {
+            operation: request.operation,
+            conversations: page.items,
+            nextCursor: page.nextCursor
+          }
+        };
+      }
+      case "getConversationRuns": {
+        const page = await store.getConversationRuns(request.agentId, request.threadId, request.cursor, request.limit ?? DEFAULT_CONVERSATION_RUN_LIST_LIMIT, request.direction);
+        return {
+          status: 200,
+          body: {
+            operation: request.operation,
+            threadId: request.threadId,
+            runs: page.items,
+            nextCursor: page.nextCursor
+          }
+        };
+      }
+      case "getConversationRunWindow": {
+        const window = await store.getConversationRunWindow(request.agentId, request.threadId, request.runId, request.beforeLimit ?? 5, request.afterLimit ?? 5);
+        return {
+          status: 200,
+          body: {
+            operation: request.operation,
+            threadId: request.threadId,
+            anchorRunId: request.runId,
+            runs: window.items,
+            olderCursor: window.olderCursor,
+            newerCursor: window.newerCursor
+          }
+        };
+      }
+      case "searchConversationMessages": {
+        const page = await store.searchConversationMessages(request.agentId, request.keyword.trim(), request.cursor, request.limit ?? DEFAULT_CONVERSATION_SEARCH_LIMIT);
+        return {
+          status: 200,
+          body: {
+            operation: request.operation,
+            keyword: request.keyword.trim(),
+            results: page.items,
+            nextCursor: page.nextCursor
+          }
+        };
+      }
+      case "createSession":
+      case "createConversation": {
+        const threadId = await store.createSession(request.agentId);
+        return {
+          status: 200,
+          body: { operation: request.operation, threadId }
+        };
+      }
+      case "activateConversation": {
+        await store.activateConversation(request.agentId, request.threadId);
+        return {
+          status: 200,
+          body: { operation: request.operation, threadId: request.threadId }
+        };
+      }
+      case "setRunBlocked": {
+        const result = await store.setRunBlocked({
+          runId: request.runId,
+          threadId: request.threadId,
+          blockQuestion: request.blockQuestion,
+          blockAnswer: request.blockAnswer,
+          questionReplacement: request.questionReplacement,
+          answerReplacement: request.answerReplacement,
+          blockedBy: historyOwnerId
+        });
+        return {
+          status: 200,
+          body: {
+            operation: request.operation,
+            runId: result.runId,
+            threadId: result.threadId,
+            blockedQuestion: result.blockedQuestion,
+            blockedAnswer: result.blockedAnswer,
+            questionReplacement: result.questionReplacement,
+            answerReplacement: result.answerReplacement,
+            blockedAt: result.blockedAt,
+            blockedBy: result.blockedBy
+          }
+        };
+      }
+    }
+  } catch (error) {
+    logCtx?.error?.("[history] \u8BF7\u6C42\u6267\u884C\u5931\u8D25:", error);
+    if (error instanceof ConversationHistoryNotFoundError) {
+      return historyError(404, "conversation_not_found", error.message);
+    }
+    return historyError(500, "history_query_failed", error instanceof Error ? error.message : "\u4F1A\u8BDD\u5386\u53F2\u67E5\u8BE2\u5931\u8D25");
+  }
+}
+function historyError(status, code, message) {
+  return { status, body: { error: { code, message, status } } };
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/handler/homeData.js
+var HOME_DATA_REQUEST_OPERATION = "homeData.request";
+async function runHomeData(method, body, userId, deps = {}, env = process.env, envSelector = "PROD", gatewayAuth, logCtx) {
+  if (method.toUpperCase() !== "POST") {
+    return jsonError(405, "method_not_allowed", "\u4EC5\u652F\u6301 POST");
+  }
+  if (!userId) {
+    return jsonError(401, "authentication_required", "\u7F3A\u5C11 Appwrite \u8BA4\u8BC1\u7528\u6237");
+  }
+  const protocol = deps.protocol ?? getBakedProtocol();
+  let provider = deps.mcpServerProvider;
+  if (!provider) {
+    let resolvedAuth;
+    try {
+      resolvedAuth = resolveGatewayAuthContext(gatewayAuth, env, logCtx, "home-data");
+    } catch {
+      return jsonError(500, "auth_unconfigured", "LINKQUE_AGENT_ACCESS_KEY \u672A\u914D\u7F6E");
+    }
+    const { mcpSignEndpoint } = resolveLinkqueEndpoints(env, envSelector);
+    provider = createAppbaseMcpProvider({
+      resolveConfig: createAppbaseMcpConfigResolver({
+        agentId: protocol.agentId,
+        ...mcpSignEndpoint ? { signEndpoint: mcpSignEndpoint } : {}
+      }),
+      getAuthorizationHeader: async () => resolvedAuth.authorizationHeader
+    });
+  }
+  const response = await executeHomeData({
+    request: body,
+    protocol,
+    userId,
+    mcpServerProvider: provider
+  });
+  return { status: 200, body: response };
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/handler/chatConfig.js
+function resolveChatDeps(env, deps, logCtx, historyOwnerId, appwriteApiKey, envSelector, gatewayAuth) {
+  const log = (...a) => logCtx?.log?.("[chat]", ...a);
+  const logError = (...a) => logCtx?.error?.("[chat]", ...a);
+  const protocol = deps?.protocol ?? getBakedProtocol();
+  log("protocol \u5DF2\u52A0\u8F7D, agentId=", protocol.agentId, "model=", protocol.agent.model.defaultModel);
+  for (const line of describeRuntimeEnv(env, Boolean(appwriteApiKey))) {
+    log("env:", line);
+  }
+  let resolved;
+  try {
+    resolved = resolveGatewayAuthContext(gatewayAuth, env, logCtx, "chat");
+    log("\u8BA4\u8BC1\u89E3\u6790\u6210\u529F, provider=", resolved.auth.provider, "mode=", resolved.mode, "model=", protocol.agent.model.defaultModel ?? "default");
+  } catch (err) {
+    logError("\u8BA4\u8BC1\u914D\u7F6E\u7F3A\u5931:", err);
+    return jsonError(500, "auth_unconfigured", err instanceof Error ? err.message : "\u8BA4\u8BC1\u914D\u7F6E\u7F3A\u5931");
+  }
+  let store = deps?.store;
+  let sessionLease = deps?.sessionLease;
+  let historyStore = deps?.historyStore;
+  let clientCapabilityStore = deps?.clientCapabilityStore;
+  let chunkSize = 30;
+  if (!store) {
+    let storage;
+    try {
+      storage = resolveRunStorage(env, logCtx);
+    } catch (err) {
+      logError("\u843D\u5E93\u914D\u7F6E\u7F3A\u5931:", err);
+      return jsonError(500, "storage_unconfigured", err instanceof Error ? err.message : "\u843D\u5E93\u914D\u7F6E\u7F3A\u5931");
+    }
+    let handle;
+    try {
+      handle = createAppBaseClient(env, logCtx, appwriteApiKey);
+    } catch (err) {
+      logError("AppBase \u51ED\u636E\u7F3A\u5931:", err);
+      return jsonError(500, "appbase_unconfigured", err instanceof Error ? err.message : "AppBase \u51ED\u636E\u7F3A\u5931");
+    }
+    store = createAppBaseStore(handle.databases, storage.databaseId, storage.tableId, historyOwnerId);
+    if (env.CLIENT_CAPABILITY_DATABASE_ID && env.CLIENT_CAPABILITY_TABLE_ID) {
+      clientCapabilityStore ??= createClientCapabilityStore(handle.databases, env.CLIENT_CAPABILITY_DATABASE_ID, env.CLIENT_CAPABILITY_TABLE_ID);
+    }
+    try {
+      historyStore ??= createConversationHistoryStore(handle.databases, resolveConversationHistoryStorage(env), historyOwnerId);
+    } catch (err) {
+      logError("\u4F1A\u8BDD\u5386\u53F2\u5B58\u50A8\u914D\u7F6E\u7F3A\u5931:", err);
+      return jsonError(500, "history_storage_unconfigured", err instanceof Error ? err.message : "\u4F1A\u8BDD\u5386\u53F2\u5B58\u50A8\u914D\u7F6E\u7F3A\u5931");
+    }
+    const sessionStorage = resolveSessionStorage(env);
+    const sessionLeaseStorage = resolveSessionLeaseStorage(env);
+    if (sessionStorage && !sessionLeaseStorage && !sessionLease) {
+      return jsonError(500, "session_lock_failed", "\u5DF2\u542F\u7528\u6301\u4E45\u5316\u4F1A\u8BDD\uFF0C\u4F46\u672A\u914D\u7F6E SESSION_LEASE_TABLE_ID");
+    }
+    if (!sessionLease && sessionLeaseStorage) {
+      sessionLease = createAppBaseSessionLease(handle.databases, sessionLeaseStorage.databaseId, sessionLeaseStorage.tableId, historyOwnerId);
+    }
+    chunkSize = storage.chunkSize;
+  }
+  const mcpAuthorizationHeaderProvider = async () => resolved.authorizationHeader;
+  const { linkqueBaseUrl, knowledgeBaseUrl, mcpSignEndpoint } = resolveLinkqueEndpoints(env, envSelector);
+  const mcpConfigResolver = createAppbaseMcpConfigResolver({
+    agentId: protocol.agentId,
+    ...mcpSignEndpoint ? { signEndpoint: mcpSignEndpoint } : {}
+  });
+  const runtime = deps?.runtime ?? createAppBaseRuntime(protocol, env, {
+    ...appwriteApiKey ? { appBaseApiKey: appwriteApiKey } : {},
+    mcpConfigResolver,
+    mcpAuthorizationHeaderProvider,
+    gatewayAgentId: protocol.agentId,
+    ...linkqueBaseUrl ? { linkqueBaseUrl } : {},
+    ...knowledgeBaseUrl ? { knowledgeBaseUrl } : {}
+  }, logCtx);
+  return {
+    auth: resolved.auth,
+    // 模型取自 bundler 已 bake-in 的 protocol 默认模型(历史来自 env AGENT_MODEL,已移除)。
+    model: protocol.agent.model.defaultModel || void 0,
+    protocol,
+    runtime,
+    store,
+    sessionLease,
+    historyStore,
+    clientCapabilityStore,
+    chunkSize
+  };
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/handler/chatDebug.js
+var DEBUG_PREVIEW_MAX = 60;
+function preview(value, max = DEBUG_PREVIEW_MAX) {
+  let str;
+  if (typeof value === "string") {
+    str = value;
+  } else {
+    try {
+      str = JSON.stringify(value) ?? "<unserializable>";
+    } catch {
+      str = "<unserializable>";
+    }
+  }
+  str = str.replace(/\s+/g, " ").trim();
+  return str.length > max ? `${str.slice(0, max)}\u2026` : str;
+}
+async function* debugLogAgentStream(stream, debugLog) {
+  const start = Date.now();
+  let firstResponseLogged = false;
+  const counts = { delta: 0, thinking: 0, tool: 0, card: 0 };
+  const summary = () => `\u4E8B\u4EF6\u603B\u6570=${counts.delta + counts.thinking + counts.tool + counts.card}(delta=${counts.delta},thinking=${counts.thinking},tool=${counts.tool},card=${counts.card})`;
+  for await (const ev of stream) {
+    switch (ev.type) {
+      case "delta":
+        counts.delta += 1;
+        if (!firstResponseLogged) {
+          firstResponseLogged = true;
+          debugLog("provider \u9996\u54CD\u5E94", `${Date.now() - start}ms`, "event=delta");
+        }
+        debugLog("agent \u4E8B\u4EF6 delta #", counts.delta, "len=", ev.content.length);
+        break;
+      case "thinking":
+        counts.thinking += 1;
+        if (!firstResponseLogged) {
+          firstResponseLogged = true;
+          debugLog("provider \u9996\u54CD\u5E94", `${Date.now() - start}ms`, "event=thinking");
+        }
+        debugLog("agent \u4E8B\u4EF6 thinking #", counts.thinking, "\u9884\u89C8=", preview(ev.content));
+        break;
+      case "tool_start":
+        counts.tool += 1;
+        debugLog("agent \u4E8B\u4EF6 tool_start tool=", ev.toolName, "args=", preview(ev.args));
+        break;
+      case "tool_end":
+        debugLog("agent \u4E8B\u4EF6 tool_end tool=", ev.toolName, "isError=", ev.isError, "result=", preview(ev.result));
+        break;
+      case "a2ui_card":
+        counts.card += 1;
+        debugLog("agent \u4E8B\u4EF6 a2ui_card cardRef=", ev.metadata.cardRef, "cardInstanceId=", ev.metadata.cardInstanceId);
+        break;
+      case "error":
+        debugLog("agent \u4E8B\u4EF6 error code=", ev.error.code ?? "AGENT_PROVIDER_ERROR", "msg=", preview(ev.error.message), "|", summary());
+        break;
+      case "done":
+        debugLog("agent \u4E8B\u4EF6 done willRetry=", ev.willRetry, "|", summary());
+        break;
+    }
+    yield ev;
+  }
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/clientCapabilityTool.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+var WAIT_TIMEOUT_MS = 2e4;
+var POLL_INTERVAL_MS = 500;
+var ROW_TTL_MS = 3 * 6e4;
+var LOCATION_INPUT = Object.freeze({
+  type: 0,
+  cacheTimeout: 30,
+  coordinateSystemType: "GCJ02"
+});
+function createClientCapabilityTool(input) {
+  const resource = input.protocol.agent.resources.find((candidate) => candidate.resourceType === EResourceType.CLIENT_CAPABILITY);
+  if (!resource || !input.ownerId || !input.store || !resource.config.allowedCapabilities.includes("location") || !input.request.clientCapabilities?.includes("location"))
+    return void 0;
+  const ownerId = input.ownerId;
+  const store = input.store;
+  let pending = false;
+  return {
+    name: "client_capability",
+    modelName: "client_capability",
+    resourceId: resource.resourceId,
+    label: "\u83B7\u53D6\u7528\u6237\u5F53\u524D\u4F4D\u7F6E",
+    description: "\u5F53\u56DE\u7B54\u786E\u5B9E\u9700\u8981\u7528\u6237\u5F53\u524D\u5730\u7406\u4F4D\u7F6E\u65F6\u8C03\u7528\u3002\u80FD\u529B\u7531\u7528\u6237\u5F53\u524D\u8BBE\u5907\u6267\u884C\uFF0C\u5931\u8D25\u65F6\u8BF7\u7EE7\u7EED\u7ED9\u51FA\u53EF\u884C\u8BF4\u660E\u3002",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["capability", "reason"],
+      properties: {
+        capability: { const: "location" },
+        reason: { type: "string", minLength: 1, maxLength: 200 }
+      }
+    },
+    execute: async (args, signal, context) => {
+      if (!context)
+        return failure("CLIENT_CAPABILITY_CONTEXT_MISSING", "\u7AEF\u4FA7\u8C03\u7528\u4E0A\u4E0B\u6587\u4E0D\u53EF\u7528");
+      if (pending)
+        return failure("CLIENT_CAPABILITY_BUSY", "\u5F53\u524D\u5DF2\u6709\u4E00\u4E2A\u7AEF\u4FA7\u80FD\u529B\u8C03\u7528\u6B63\u5728\u7B49\u5F85");
+      const parsed = readArgs(args);
+      if (!parsed)
+        return failure("CLIENT_CAPABILITY_INVALID_ARGS", "\u7AEF\u4FA7\u5B9A\u4F4D\u53C2\u6570\u4E0D\u5408\u6CD5");
+      pending = true;
+      const invocationId = randomUUID2();
+      const now = Date.now();
+      const acceptUntil = new Date(now + WAIT_TIMEOUT_MS).toISOString();
+      const expiresAt = new Date(now + ROW_TTL_MS).toISOString();
+      let created = false;
+      try {
+        await store.create({
+          invocationId,
+          ownerId,
+          agentId: input.protocol.agentId,
+          threadId: input.request.threadId,
+          runId: input.request.runId,
+          toolCallId: context.toolCallId,
+          capability: "location",
+          status: "pending",
+          input: JSON.stringify(LOCATION_INPUT),
+          createdAt: new Date(now).toISOString(),
+          acceptUntil,
+          expiresAt
+        });
+        created = true;
+        context.emit({
+          type: "client_capability_request",
+          value: {
+            version: "1.0",
+            invocationId,
+            runId: input.request.runId,
+            toolCallId: context.toolCallId,
+            capability: "location",
+            reason: parsed.reason,
+            input: LOCATION_INPUT,
+            expiresAt: acceptUntil
+          }
+        });
+        while (Date.now() < Date.parse(acceptUntil)) {
+          if (signal?.aborted)
+            throw abortError();
+          const row = await store.get(invocationId);
+          if (row?.status === "succeeded" || row?.status === "failed") {
+            const result = parseStoredClientCapabilityResult(row.result);
+            if (!result)
+              return failure("CLIENT_CAPABILITY_INVALID_RESULT", "\u7AEF\u4FA7\u8FD4\u56DE\u5185\u5BB9\u65E0\u6CD5\u89E3\u6790");
+            await store.consume(invocationId);
+            return result;
+          }
+          await wait(POLL_INTERVAL_MS, signal);
+        }
+        await store.expire(invocationId);
+        return failure("CLIENT_CAPABILITY_TIMEOUT", "\u7B49\u5F85\u7AEF\u4FA7\u5B9A\u4F4D\u7ED3\u679C\u8D85\u65F6", true);
+      } catch (error) {
+        if (created && signal?.aborted)
+          await store.expire(invocationId);
+        throw error;
+      } finally {
+        pending = false;
+      }
+    }
+  };
+}
+function readArgs(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return void 0;
+  const args = value;
+  if (args.capability !== "location" || typeof args.reason !== "string")
+    return void 0;
+  const reason = args.reason.trim();
+  return reason && reason.length <= 200 ? { reason } : void 0;
+}
+function failure(code, message, retriable = false) {
+  return { ok: false, error: { code, message, retriable } };
+}
+function wait(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted)
+      return reject(abortError());
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError());
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function abortError() {
+  const error = new Error("client capability call aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/handler/chatExecution.js
+async function runAgentToChunks(deps, request, env, logCtx, authenticatedUserId, signal, traceId) {
+  const log = (...a) => logCtx?.log?.("[chat]", ...a);
+  const logError = (...a) => logCtx?.error?.("[chat]", ...a);
+  const debug = isDebugLogLevel(env);
+  const debugLog = (...args) => {
+    if (debug)
+      logCtx?.log?.("[chat][debug]", ...args);
+  };
+  const sink = new ChunkSink(deps.store, { runId: request.runId, threadId: request.threadId }, { chunkSize: deps.chunkSize });
+  let firstChunkId;
+  try {
+    firstChunkId = await sink.open();
+    log("chunk#0 \u521B\u5EFA\u6210\u529F, id=", firstChunkId);
+  } catch (err) {
+    logError("chunk#0 \u521B\u5EFA\u5931\u8D25:", err);
+    return {
+      response: jsonError(500, "chunk_create_failed", err instanceof Error ? err.message : "chunk#0 \u521B\u5EFA\u5931\u8D25"),
+      runStatus: "error",
+      totalChunks: 0,
+      searchMessages: []
+    };
+  }
+  const runOptions = {
+    runtimeContext: {
+      agentId: deps.protocol.agentId,
+      threadId: request.threadId,
+      ...authenticatedUserId ? { userId: authenticatedUserId } : {}
+    },
+    // hook 公共参数 host 注入:traceId 来自请求头(x-trace-id);runIndex 不注入,
+    // 由 runtime 按已加载会话历史用户轮次 + 1 强准确推导(会话维度历史本就由本包维护)。
+    ...traceId ? { hookContext: { traceId } } : {}
+  };
+  if (request.executionScope !== "presentation") {
+    runOptions.sessionId = request.threadId;
+  }
+  if (deps.model)
+    runOptions.model = deps.model;
+  const clientCapabilityTool = createClientCapabilityTool({
+    protocol: deps.protocol,
+    request,
+    ownerId: authenticatedUserId,
+    store: deps.clientCapabilityStore
+  });
+  if (clientCapabilityTool)
+    runOptions.additionalTools = [clientCapabilityTool];
+  if (signal)
+    runOptions.signal = signal;
+  const agentReq = {
+    threadId: request.threadId,
+    runId: request.runId,
+    messages: toAgentRunMessages(request),
+    clientCapabilities: request.clientCapabilities
+  };
+  log("\u5F00\u59CB\u8FD0\u884C agent conversation...");
+  debugLog("\u8C03\u7528 provider, provider=", deps.auth.provider, "model=", deps.model ?? deps.protocol.agent.model.defaultModel, "sessionId=", request.threadId);
+  let status = "done";
+  let loopErrorSeen = false;
+  const assistantMessages = /* @__PURE__ */ new Map();
+  try {
+    const rawStream = deps.runtime.runAgentLoop(agentReq, deps.auth, runOptions);
+    const agentStream = debug ? debugLogAgentStream(rawStream, debugLog) : rawStream;
+    const sseStream = streamToConversationEvents(agentStream, { threadId: request.threadId, runId: request.runId }, signal ? { signal } : {});
+    for await (const ev of sseStream) {
+      if (ev.event === "transport-error") {
+        loopErrorSeen = true;
+        logError("agent loop \u5931\u8D25\u4E8B\u4EF6, code=", ev.data.code, "message=", ev.data.message);
+        status = ev.data.code === "RUN_CANCELLED" ? "cancelled" : "error";
+      }
+      if (ev.event === "ag-ui" && ev.data.type === EventType.TEXT_MESSAGE_CONTENT) {
+        const textEvent = ev.data;
+        const existing = assistantMessages.get(textEvent.messageId);
+        assistantMessages.set(textEvent.messageId, {
+          content: `${existing?.content ?? ""}${textEvent.delta}`,
+          sequence: existing?.sequence ?? assistantMessages.size + 1
+        });
+      }
+      const chunk = encodeConversationSseEvent(ev);
+      await sink.writeChunk(chunk, { flush: shouldFlushConversationEvent(ev) });
+    }
+    if (loopErrorSeen) {
+      log("agent \u6D41\u7ED3\u675F(\u542B loop \u5931\u8D25\u4E8B\u4EF6), \u5DF2\u5EFA chunk \u6570=", sink.totalChunks);
+    } else {
+      log("agent \u6D41\u6B63\u5E38\u7ED3\u675F, \u5DF2\u5EFA chunk \u6570=", sink.totalChunks);
+    }
+  } catch (err) {
+    const cancelled = signal?.aborted === true;
+    const message = cancelled ? "\u7528\u6237\u5DF2\u505C\u6B62\u672C\u6B21\u56DE\u590D\u3002" : err instanceof Error ? err.message : "unknown gateway error";
+    logError("agent \u6D41\u8FD0\u884C\u9519\u8BEF:", message);
+    status = cancelled ? "cancelled" : "error";
+    await sink.writeChunk(encodeConversationSseEvent({
+      event: "transport-error",
+      data: {
+        code: cancelled ? "RUN_CANCELLED" : "GATEWAY_ERROR",
+        message,
+        retriable: false
+      }
+    }), { flush: true });
+  } finally {
+    try {
+      await sink.finalize(status);
+      log("chunk \u5DF2 finalize, status=", status, "\u603B chunk \u6570=", sink.totalChunks);
+    } catch (err) {
+      logError("finalize \u5931\u8D25:", err);
+    }
+  }
+  return {
+    response: {
+      status: 201,
+      body: { runId: request.runId, threadId: request.threadId }
+    },
+    runStatus: status,
+    totalChunks: sink.totalChunks,
+    searchMessages: [...assistantMessages.entries()].flatMap(([itemId, message]) => message.content.trim() ? [{ itemId, content: message.content, sequence: message.sequence }] : [])
+  };
+}
+function shouldFlushConversationEvent(event) {
+  if (event.event === "transport-error")
+    return true;
+  if (event.event !== "ag-ui")
+    return false;
+  return event.data.type === EventType.TEXT_MESSAGE_END || event.data.type === EventType.TOOL_CALL_START || event.data.type === EventType.TOOL_CALL_END || event.data.type === EventType.CUSTOM || event.data.type === EventType.RUN_FINISHED;
+}
+
+// ../linkque-agent-appwrite-integrate/dist/esm/runtime/handler/chat.js
+async function runChat(method, bodyJSON, env, deps, logCtx, historyOwnerId, appwriteApiKey, envSelector, traceId, gatewayAuth) {
+  const log = (...args) => logCtx?.log?.("[chat]", ...args);
+  const logError = (...args) => logCtx?.error?.("[chat]", ...args);
+  const guarded = guardChatRequest(method, bodyJSON, logCtx);
+  if ("status" in guarded)
+    return guarded;
+  const request = guarded;
+  const isPresentationRun = request.executionScope === "presentation";
+  const cfg = resolveChatDeps(env, deps, logCtx, historyOwnerId, appwriteApiKey, envSelector, gatewayAuth);
+  if ("status" in cfg)
+    return cfg;
+  const leaseOwnerId = randomUUID3();
+  let leaseAcquired = false;
+  let leaseReleased = false;
+  if (cfg.sessionLease && !isPresentationRun) {
+    try {
+      leaseAcquired = await cfg.sessionLease.acquire(request.threadId, leaseOwnerId);
+    } catch (err) {
+      logError("session \u79DF\u7EA6\u83B7\u53D6\u5931\u8D25:", err);
+      return jsonError(500, "session_lock_failed", err instanceof Error ? err.message : "\u4F1A\u8BDD\u79DF\u7EA6\u83B7\u53D6\u5931\u8D25");
+    }
+    if (!leaseAcquired) {
+      return jsonError(409, "thread_busy", "\u8BE5\u4F1A\u8BDD\u5DF2\u6709\u6B63\u5728\u8FD0\u884C\u7684\u8BF7\u6C42");
+    }
+  }
+  const releaseLease = async () => {
+    if (!leaseAcquired || !cfg.sessionLease)
+      return true;
+    if (leaseReleased)
+      return true;
+    try {
+      await cfg.sessionLease.release(request.threadId, leaseOwnerId);
+      leaseReleased = true;
+      return true;
+    } catch (err) {
+      logError("session \u79DF\u7EA6\u91CA\u653E\u5931\u8D25:", err);
+      return false;
+    }
+  };
+  try {
+    if (cfg.historyStore && !isPresentationRun) {
+      try {
+        await cfg.historyStore.beginRun(request, cfg.protocol.agentId);
+      } catch (err) {
+        logError("\u4F1A\u8BDD\u76EE\u5F55\u521D\u59CB\u5316\u5931\u8D25:", err);
+        return jsonError(500, "history_begin_failed", err instanceof Error ? err.message : "\u4F1A\u8BDD\u76EE\u5F55\u521D\u59CB\u5316\u5931\u8D25");
+      }
+      const userSearchContent = readSearchableUserContent(request);
+      if (userSearchContent) {
+        try {
+          await cfg.historyStore.indexSearchMessages([
+            {
+              agentId: cfg.protocol.agentId,
+              threadId: request.threadId,
+              runId: request.runId,
+              itemId: `${request.runId}:user`,
+              role: "user",
+              content: userSearchContent,
+              createdAt: Date.now(),
+              sequence: 0
+            }
+          ]);
+        } catch (err) {
+          logError("\u7528\u6237\u6D88\u606F\u641C\u7D22\u7D22\u5F15\u5199\u5165\u5931\u8D25:", err);
+        }
+      }
+    }
+    const runAbortController = new AbortController();
+    const stopCancellationObserver = startRunCancellationObserver(isPresentationRun ? void 0 : cfg.historyStore, cfg.protocol.agentId, request.runId, runAbortController, env, logCtx);
+    let execution;
+    try {
+      execution = await runAgentToChunks(cfg, request, env, logCtx, historyOwnerId, runAbortController.signal, traceId);
+    } catch (err) {
+      logError("Agent \u6267\u884C\u5757\u5F02\u5E38\u9000\u51FA:", err);
+      if (cfg.historyStore && !isPresentationRun) {
+        try {
+          await cfg.historyStore.completeRun({
+            runId: request.runId,
+            threadId: request.threadId,
+            status: "error",
+            totalChunks: 0
+          });
+        } catch (historyError2) {
+          logError("\u5F02\u5E38 run \u7D22\u5F15\u7EC8\u6001\u66F4\u65B0\u5931\u8D25:", historyError2);
+        }
+      }
+      return jsonError(500, "run_execution_failed", err instanceof Error ? err.message : "Agent \u6267\u884C\u5931\u8D25");
+    } finally {
+      await stopCancellationObserver();
+    }
+    if (cfg.historyStore && !isPresentationRun) {
+      try {
+        await cfg.historyStore.completeRun({
+          runId: request.runId,
+          threadId: request.threadId,
+          status: execution.runStatus,
+          totalChunks: execution.totalChunks
+        });
+      } catch (err) {
+        logError("\u4F1A\u8BDD run \u7D22\u5F15\u7EC8\u6001\u66F4\u65B0\u5931\u8D25:", err);
+      }
+      if (execution.searchMessages.length) {
+        const createdAt = Date.now();
+        try {
+          await cfg.historyStore.indexSearchMessages(execution.searchMessages.map((message) => ({
+            agentId: cfg.protocol.agentId,
+            threadId: request.threadId,
+            runId: request.runId,
+            itemId: message.itemId,
+            role: "assistant",
+            content: message.content,
+            createdAt,
+            sequence: message.sequence
+          })));
+        } catch (err) {
+          logError("\u667A\u80FD\u4F53\u6D88\u606F\u641C\u7D22\u7D22\u5F15\u5199\u5165\u5931\u8D25:", err);
+        }
+      }
+    }
+    let preparedFollowUpContext;
+    log("\u8FFD\u95EE\u89E6\u53D1\u68C0\u67E5:", {
+      runStatus: execution.runStatus,
+      assistantMessageCount: execution.searchMessages.length,
+      hasHistoryWriter: Boolean(cfg.historyStore?.saveFollowUpQuestions),
+      hasContextPreparer: Boolean(cfg.runtime.prepareFollowUpQuestionContext),
+      hasGenerator: Boolean(cfg.runtime.generateFollowUpQuestions)
+    });
+    if (!isPresentationRun && execution.runStatus === "done" && execution.searchMessages.length > 0 && cfg.historyStore?.saveFollowUpQuestions && cfg.runtime.prepareFollowUpQuestionContext && cfg.runtime.generateFollowUpQuestions) {
+      let followUpHistory = [];
+      if (cfg.historyStore.getRecentFollowUpQuestionContext) {
+        try {
+          followUpHistory = await cfg.historyStore.getRecentFollowUpQuestionContext(cfg.protocol.agentId, request.threadId, request.runId, FOLLOW_UP_CONTEXT_MAX_HISTORY_RUNS);
+        } catch (err) {
+          logError("\u8FFD\u95EE\u5386\u53F2\u53C2\u8003\u52A0\u8F7D\u5931\u8D25:", err);
+        }
+      }
+      try {
+        preparedFollowUpContext = await cfg.runtime.prepareFollowUpQuestionContext(request.threadId, followUpHistory);
+        log("\u8FFD\u95EE\u4E0A\u4E0B\u6587\u5FEB\u7167\u5B8C\u6210:", {
+          prepared: Boolean(preparedFollowUpContext),
+          messageCount: preparedFollowUpContext?.messages.length ?? 0,
+          historyCount: preparedFollowUpContext?.history?.length ?? 0
+        });
+      } catch (err) {
+        logError("\u8FFD\u95EE\u4E0A\u4E0B\u6587\u5FEB\u7167\u5931\u8D25:", err);
+      }
+    }
+    const released = await releaseLease();
+    if (released && preparedFollowUpContext && cfg.historyStore?.saveFollowUpQuestions && cfg.runtime.generateFollowUpQuestions) {
+      try {
+        const questions = await cfg.runtime.generateFollowUpQuestions(preparedFollowUpContext, cfg.auth, {
+          runId: request.runId,
+          runtimeContext: {
+            agentId: cfg.protocol.agentId,
+            threadId: request.threadId,
+            ...historyOwnerId ? { userId: historyOwnerId } : {}
+          }
+        });
+        log("\u8FFD\u95EE\u751F\u6210\u5B8C\u6210:", { questionCount: questions.length });
+        if (questions.length > 0) {
+          await cfg.historyStore.saveFollowUpQuestions(request.runId, request.threadId, {
+            questions: questions.map((question) => ({
+              label: question,
+              prompt: question
+            }))
+          });
+        }
+      } catch (err) {
+        logError("\u8FFD\u95EE\u751F\u6210\u6216\u5199\u5165\u5931\u8D25:", err);
+      }
+    }
+    return execution.response;
+  } finally {
+    await releaseLease();
+  }
+}
+function readSearchableUserContent(request) {
+  const content = request.messages.at(-1)?.content;
+  if (typeof content === "string")
+    return content.trim();
+  return "";
+}
+var DEFAULT_CANCEL_POLL_INTERVAL_MS = 500;
+function startRunCancellationObserver(store, agentId, runId, runAbortController, env, logCtx) {
+  if (!store?.isRunCancellationRequested)
+    return async () => void 0;
+  const observerAbortController = new AbortController();
+  const intervalMs = readCancelPollInterval(env);
+  let queryErrorLogged = false;
+  const task = (async () => {
+    while (!observerAbortController.signal.aborted && !runAbortController.signal.aborted) {
+      try {
+        const requested = await store.isRunCancellationRequested?.(agentId, runId);
+        queryErrorLogged = false;
+        if (requested) {
+          logCtx?.log?.("[chat] \u6536\u5230 run \u53D6\u6D88\u8BF7\u6C42, runId=", runId);
+          runAbortController.abort();
+          return;
+        }
+      } catch (error) {
+        if (!queryErrorLogged) {
+          queryErrorLogged = true;
+          logCtx?.error?.("[chat] \u67E5\u8BE2 run \u53D6\u6D88\u72B6\u6001\u5931\u8D25\uFF0C\u5C06\u7EE7\u7EED\u91CD\u8BD5:", error);
+        }
+      }
+      await waitForCancellationPoll(intervalMs, observerAbortController.signal);
+    }
+  })();
+  return async () => {
+    observerAbortController.abort();
+    await task.catch(() => void 0);
+  };
+}
+function readCancelPollInterval(env) {
+  const configured = Number(env.RUN_CANCEL_POLL_INTERVAL_MS);
+  return Number.isSafeInteger(configured) && configured >= 100 ? Math.min(configured, 5e3) : DEFAULT_CANCEL_POLL_INTERVAL_MS;
+}
+function waitForCancellationPoll(delayMs, signal) {
+  if (signal.aborted)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(finish, delayMs);
+    signal.addEventListener("abort", finish, { once: true });
+    function finish() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve();
+    }
+  });
+}
+async function runGateway(method, bodyJSON, env, deps, logCtx, historyOwnerId, appwriteApiKey, envSelector, traceId, gatewayAuth) {
+  const operation = readOperation(bodyJSON);
+  if (operation === "cancelConversationRun") {
+    return runCancelConversation(method, bodyJSON, env, deps ? { protocol: deps.protocol, store: deps.historyStore } : void 0, logCtx, historyOwnerId, appwriteApiKey);
+  }
+  if (operation === ASR_CREATE_CREDENTIAL_OPERATION) {
+    const agentId = deps?.protocol?.agentId ?? getBakedProtocol().agentId;
+    return runAsrCredential(method, env, historyOwnerId, agentId, void 0, envSelector, gatewayAuth, logCtx);
+  }
+  if (operation === ATTACHMENT_CREATE_UPLOAD_TOKEN_OPERATION) {
+    const agentId = deps?.protocol?.agentId ?? getBakedProtocol().agentId;
+    return runAttachmentUploadToken(method, env, historyOwnerId, agentId, void 0, envSelector, gatewayAuth, logCtx);
+  }
+  if (operation === HOME_DATA_REQUEST_OPERATION) {
+    const request = readOperationPayload(bodyJSON);
+    return runHomeData(method, request, historyOwnerId, {
+      ...deps?.protocol ? { protocol: deps.protocol } : {},
+      ...deps?.mcpServerProvider ? { mcpServerProvider: deps.mcpServerProvider } : {}
+    }, env, envSelector === "PRE" ? "PRE" : "PROD");
+  }
+  if (operation && HISTORY_OPERATIONS.has(operation)) {
+    return runHistory(method, bodyJSON, env, deps ? { protocol: deps.protocol, store: deps.historyStore } : void 0, logCtx, historyOwnerId, appwriteApiKey);
+  }
+  if (operation?.startsWith("attachment.")) {
+    return jsonError(501, "operation_not_implemented", "\u9644\u4EF6 operation \u5DF2\u9884\u7559\uFF0C\u5F53\u524D\u7248\u672C\u672A\u5B9E\u73B0");
+  }
+  if (operation) {
+    return jsonError(400, "operation_unsupported", `\u4E0D\u652F\u6301\u7684 operation: ${operation}`);
+  }
+  return runChat(method, bodyJSON, env, deps, logCtx, historyOwnerId, appwriteApiKey, envSelector, traceId, gatewayAuth);
+}
+async function chat(ctx) {
+  let result;
+  try {
+    const bodyJSON = resolveBodyJSON(ctx.req);
+    const historyOwnerId = readAuthenticatedUserId(ctx.req.headers);
+    const appwriteApiKey = readAppwriteApiKey(ctx.req.headers);
+    const envSelector = readEnvSelector(ctx.req.headers);
+    const traceId = readTraceId(ctx.req.headers);
+    const gatewayAuth = historyOwnerId ? resolveLinkqueGatewayAuth(ctx.req.headers, process.env, {
+      log: ctx.log,
+      error: ctx.error
+    }) : void 0;
+    result = historyOwnerId ? await runGateway(ctx.req.method, bodyJSON, process.env, void 0, { log: ctx.log, error: ctx.error }, historyOwnerId, appwriteApiKey, envSelector, traceId, gatewayAuth) : jsonError(401, "authentication_required", "\u7F3A\u5C11 Appwrite \u8BA4\u8BC1\u7528\u6237");
+  } catch (err) {
+    ctx.error?.(err);
+    result = err instanceof LinkqueGatewayAuthError || err instanceof LinkqueGatewayAuthUnconfiguredError ? jsonError(err.status, err.code, err.message) : {
+      status: 500,
+      body: {
+        error: {
+          code: "INTERNAL_ERROR",
+          message: err instanceof Error ? err.message : "unknown error"
+        }
+      }
+    };
+  }
+  if (result.body === void 0) {
+    return ctx.res.empty?.();
+  }
+  return ctx.res.json?.(result.body, result.status);
+}
+var HISTORY_OPERATIONS = /* @__PURE__ */ new Set([
+  "activateConversation",
+  "bootstrap",
+  "createConversation",
+  "createSession",
+  "getConversationRuns",
+  "getConversationRunWindow",
+  "listConversations",
+  "searchConversationMessages",
+  "setRunBlocked"
+]);
+function readOperation(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return void 0;
+  const operation = value.operation;
+  return typeof operation === "string" && operation ? operation : void 0;
+}
+function readOperationPayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const payload = { ...value };
+  delete payload.operation;
+  return payload;
+}
+export {
+  chat as default,
+  runChat,
+  runGateway
+};