@nema-project/nema 0.0.0-stage → 0.1.4

package/dist/direct/siwc.js

@@ -0,0 +1,403 @@
+// direct/siwc.js
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { closeSync, constants, mkdirSync, openSync, readFileSync, writeSync } from "node:fs";
+import { createServer } from "node:http";
+import path from "node:path";
+import { AuthStore, RefreshError, ReloginRequiredError } from "./authStore.js";
+import { decodeJwtPayload } from "./jwt.js";
+import { withFileLock } from "./lock.js";
+import { protectPrivatePath } from "../secrets/permissions.js";
+var SIWC = {
+  /** [SIGN-IN] first-time registration entrypoint; never saved or used for token exchange. */
+  dynamicClientId: "dynamic_agent_client",
+  /** [SIGN-IN] app's actual name, used consistently, only on initial registration. */
+  agentNameHint: "Nema Room",
+  /** [SIGN-IN] */
+  authorizeUrl: "https://auth.openai.com/api/accounts/authorize",
+  /** [SIGN-IN] code exchange; [SESSIONS] refresh. */
+  tokenUrl: "https://auth.openai.com/api/accounts/oauth/token",
+  /** [TOKENS] access-token `iss` in production. */
+  issuer: "https://auth.openai.com",
+  /** [SIGN-IN] `resource` on authorize, exchange and refresh. */
+  resource: "https://api.openai.com/v1",
+  /** [SIGN-IN] identity scopes (needed for the id_token / account identity). */
+  identityScopes: "openid profile email",
+  /** [SIGN-IN] ChatGPT plan usage scopes. */
+  planScopes: "offline_access resource.invoke chatgpt.tokens.use.direct",
+  /** [SIGN-IN] the granted scope that authorizes plan usage. */
+  planUsageScope: "chatgpt.tokens.use.direct",
+  /** [SIGN-IN] loopback redirect `http://127.0.0.1:<port>/auth/callback`; only the port may vary. */
+  callbackHost: "127.0.0.1",
+  callbackPath: "/auth/callback",
+  /** [SIGN-IN] example port. */
+  defaultPort: 1455,
+  /** [MODELS] */
+  apiBase: "https://api.openai.com/v1",
+  /** Project rule (not from the docs). */
+  originator: "nema-room"
+};
+var UNUSABLE_REFRESH_CODES = [
+  "invalid_grant",
+  "invalid_client",
+  // the saved client registration is gone: log in again with a NEW client
+  "invalid_refresh_token",
+  "token_expired",
+  "refresh_token_expired",
+  "refresh_token_invalidated",
+  "refresh_token_reused"
+];
+var EXCHANGE_TIMEOUT_MS = 3e4;
+var cachedVersion;
+function cliVersion() {
+  if (cachedVersion)
+    return cachedVersion;
+  try {
+    const pkg = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+    cachedVersion = typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    cachedVersion = "0.0.0";
+  }
+  return cachedVersion;
+}
+var nemaUserAgent = () => `NemaRoom/${cliVersion()}`;
+var nemaHeaders = () => ({ originator: SIWC.originator, "User-Agent": nemaUserAgent() });
+function hostId(nemaHome) {
+  const file = path.join(nemaHome, "host-id");
+  const readExisting = () => {
+    try {
+      const v = readFileSync(file, "utf8").trim();
+      return v === "" ? null : v;
+    } catch (e) {
+      if (e.code === "ENOENT")
+        return null;
+      throw e;
+    }
+  };
+  const existing = readExisting();
+  if (existing)
+    return existing;
+  mkdirSync(nemaHome, { recursive: true, mode: 448 });
+  const id = `urn:uuid:${randomUUID()}`;
+  try {
+    const fd = openSync(file, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 384);
+    try {
+      writeSync(fd, id + "\n");
+    } finally {
+      closeSync(fd);
+    }
+    protectPrivatePath(file, 384);
+    return id;
+  } catch (e) {
+    if (e.code !== "EEXIST")
+      throw e;
+    const raced = readExisting();
+    if (!raced)
+      throw e;
+    return raced;
+  }
+}
+var b64url = (buf) => buf.toString("base64url");
+var randomToken = () => b64url(randomBytes(32));
+function safeEqual(a, b) {
+  const ab = Buffer.from(a, "utf8");
+  const bb = Buffer.from(b, "utf8");
+  return ab.length === bb.length && timingSafeEqual(ab, bb);
+}
+function listen(server, port) {
+  return new Promise((resolve, reject) => {
+    const onError = (e) => {
+      server.off("listening", onListening);
+      reject(e);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve(server.address().port);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, SIWC.callbackHost);
+  });
+}
+async function startCallbackServer(server, port) {
+  const wanted = port ?? SIWC.defaultPort;
+  try {
+    return await listen(server, wanted);
+  } catch (e) {
+    const code = e.code;
+    if (code === "EADDRINUSE" && port === void 0)
+      return listen(server, 0);
+    if (code === "EADDRINUSE")
+      throw new Error(`\u767B\u5F55\u56DE\u8C03\u7AEF\u53E3 ${SIWC.callbackHost}:${wanted} \u5DF2\u88AB\u5360\u7528\uFF0C\u8BF7\u6362\u4E00\u4E2A\u7AEF\u53E3\uFF08--port\uFF09`, { cause: e });
+    throw e;
+  }
+}
+function page(res, status, message) {
+  if (res.writableEnded)
+    return;
+  res.writeHead(status, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
+  const esc = message.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+  res.end(`<!doctype html><meta charset="utf-8"><title>Nema Room</title><p>${esc}</p>`);
+}
+function waitForCallback(server, expected, timeoutMs, signal, redactErrors = false) {
+  return new Promise((resolve, reject) => {
+    let done = false;
+    const finish = (fn) => {
+      if (done)
+        return;
+      done = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      fn();
+    };
+    const onAbort = () => finish(() => reject(signal?.reason ?? new DOMException("Aborted", "AbortError")));
+    const timer = setTimeout(() => finish(() => reject(new Error(`\u767B\u5F55\u8D85\u65F6\uFF1A${Math.round(timeoutMs / 1e3)} \u79D2\u5185\u672A\u6536\u5230\u6D4F\u89C8\u5668\u56DE\u8C03`))), timeoutMs);
+    if (signal?.aborted)
+      return onAbort();
+    signal?.addEventListener("abort", onAbort, { once: true });
+    server.on("request", (req, res) => {
+      const url = new URL(req.url ?? "/", `http://${SIWC.callbackHost}`);
+      if (req.method !== "GET" || url.pathname !== SIWC.callbackPath) {
+        res.writeHead(404).end();
+        return;
+      }
+      if (done) {
+        page(res, 409, "\u6B64\u767B\u5F55\u8BF7\u6C42\u5DF2\u5904\u7406\uFF0C\u53EF\u4EE5\u5173\u95ED\u6B64\u9875\u9762\u3002");
+        return;
+      }
+      const q = url.searchParams;
+      const fail = (status, msg) => {
+        page(res, status, redactErrors ? "Login failed. Return to Nema Room settings." : msg);
+        finish(() => reject(new Error(msg)));
+      };
+      if (!safeEqual(q.get("state") ?? "", expected.state))
+        return fail(400, "\u767B\u5F55\u5931\u8D25\uFF1Astate \u4E0D\u5339\u914D\uFF0C\u5DF2\u62D2\u7EDD\u6B64\u56DE\u8C03");
+      const error = q.get("error");
+      if (error)
+        return fail(400, `\u767B\u5F55\u5931\u8D25\uFF1A\u6388\u6743\u670D\u52A1\u5668\u8FD4\u56DE ${error}${error === "access_denied" ? "\uFF08\u7528\u6237\u62D2\u7EDD\u6388\u6743\uFF09" : ""}`);
+      const code = q.get("code");
+      if (!code)
+        return fail(400, "\u767B\u5F55\u5931\u8D25\uFF1A\u56DE\u8C03\u7F3A\u5C11 code");
+      const returned = q.get("client_id") ?? void 0;
+      let clientId;
+      if (expected.clientId) {
+        if (returned !== void 0 && returned !== expected.clientId) {
+          return fail(400, "\u767B\u5F55\u5931\u8D25\uFF1A\u56DE\u8C03\u8FD4\u56DE\u7684 client_id \u4E0E\u5DF2\u4FDD\u5B58\u7684\u6CE8\u518C\u4E0D\u4E00\u81F4\uFF0C\u5DF2\u62D2\u7EDD");
+        }
+        clientId = expected.clientId;
+      } else {
+        if (!returned || returned === SIWC.dynamicClientId)
+          return fail(400, "\u767B\u5F55\u5931\u8D25\uFF1A\u9996\u6B21\u6CE8\u518C\u7684\u56DE\u8C03\u7F3A\u5C11\u7B7E\u53D1\u7684 client_id\uFF0C\u6CE8\u518C\u672A\u5B8C\u6210");
+        clientId = returned;
+      }
+      finish(() => resolve({ code, clientId, scope: q.get("scope") ?? void 0, res }));
+    });
+  });
+}
+async function errorCode(res) {
+  try {
+    const body = await res.json();
+    const err = body.error;
+    if (typeof err === "string")
+      return { code: err, detail: typeof body.error_description === "string" ? body.error_description : void 0 };
+    if (err && typeof err === "object") {
+      const o = err;
+      return {
+        code: typeof o.code === "string" ? o.code : typeof o.type === "string" ? o.type : void 0,
+        detail: typeof o.message === "string" ? o.message : void 0
+      };
+    }
+    if (typeof body.detail === "string")
+      return { detail: body.detail };
+  } catch {
+  }
+  return {};
+}
+async function exchangeCode(tokenUrl, form, signal) {
+  const res = await fetch(tokenUrl, {
+    method: "POST",
+    headers: { ...nemaHeaders(), "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+    body: new URLSearchParams(form).toString(),
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(EXCHANGE_TIMEOUT_MS)]) : AbortSignal.timeout(EXCHANGE_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    const { code, detail } = await errorCode(res);
+    throw new Error(`\u6362\u53D6\u4EE4\u724C\u5931\u8D25\uFF1AHTTP ${res.status}${code ? ` ${code}` : ""}${detail ? `\uFF08${detail}\uFF09` : ""}`);
+  }
+  const body = await res.json();
+  if (typeof body.access_token !== "string" || body.access_token === "")
+    throw new Error("\u6362\u53D6\u4EE4\u724C\u5931\u8D25\uFF1A\u54CD\u5E94\u7F3A\u5C11 access_token");
+  if (typeof body.refresh_token !== "string" || body.refresh_token === "") {
+    throw new Error("\u6362\u53D6\u4EE4\u724C\u5931\u8D25\uFF1A\u54CD\u5E94\u7F3A\u5C11 refresh_token\uFF08\u672A\u6388\u4E88 offline_access\uFF09");
+  }
+  return {
+    access_token: body.access_token,
+    refresh_token: body.refresh_token,
+    id_token: typeof body.id_token === "string" ? body.id_token : void 0,
+    scope: typeof body.scope === "string" ? body.scope : void 0
+  };
+}
+function validateIdToken(idToken, expected) {
+  if (!idToken)
+    throw new Error("\u767B\u5F55\u5931\u8D25\uFF1A\u4EE4\u724C\u54CD\u5E94\u7F3A\u5C11 id_token");
+  let claims;
+  try {
+    claims = decodeJwtPayload(idToken);
+  } catch {
+    throw new Error("\u767B\u5F55\u5931\u8D25\uFF1Aid_token \u65E0\u6CD5\u89E3\u6790");
+  }
+  if (claims.iss !== SIWC.issuer)
+    throw new Error("\u767B\u5F55\u5931\u8D25\uFF1Aid_token \u7684 issuer \u4E0D\u7B26");
+  const aud = claims.aud;
+  const audOk = typeof aud === "string" ? aud === expected.clientId : Array.isArray(aud) && aud.includes(expected.clientId);
+  if (!audOk)
+    throw new Error("\u767B\u5F55\u5931\u8D25\uFF1Aid_token \u7684 audience \u4E0E\u7B7E\u53D1\u7684 client_id \u4E0D\u7B26");
+  if (typeof claims.nonce !== "string" || !safeEqual(claims.nonce, expected.nonce))
+    throw new Error("\u767B\u5F55\u5931\u8D25\uFF1Aid_token \u7684 nonce \u4E0D\u5339\u914D");
+  if (typeof claims.exp === "number" && claims.exp <= expected.nowS)
+    throw new Error("\u767B\u5F55\u5931\u8D25\uFF1Aid_token \u5DF2\u8FC7\u671F");
+  if (typeof claims.sub !== "string" || claims.sub === "")
+    throw new Error("\u767B\u5F55\u5931\u8D25\uFF1Aid_token \u7F3A\u5C11 sub");
+  return claims.sub;
+}
+function grantedScopes(tokens, callbackScope) {
+  if (tokens.scope !== void 0)
+    return tokens.scope.split(/[\s+]+/).filter(Boolean);
+  try {
+    const s = decodeJwtPayload(tokens.access_token).scope;
+    if (typeof s === "string")
+      return s.split(/\s+/).filter(Boolean);
+  } catch {
+  }
+  return callbackScope !== void 0 ? callbackScope.split(/[\s+]+/).filter(Boolean) : null;
+}
+async function siwcLogin(opts) {
+  const { nemaHome } = opts;
+  const authorizeUrl = opts.endpoints?.authorizeUrl ?? SIWC.authorizeUrl;
+  const tokenUrl = opts.endpoints?.tokenUrl ?? SIWC.tokenUrl;
+  const timeoutMs = opts.timeoutMs ?? 3e5;
+  const store = new AuthStore(nemaHome, siwcRefresher);
+  opts.signal?.throwIfAborted();
+  const prior = store.read();
+  const savedClientId = prior && prior.mode === "siwc" && prior.clientId !== "" && prior.clientId !== SIWC.dynamicClientId && prior.lastAuthError?.code !== "invalid_client" ? prior.clientId : void 0;
+  const extAgentHostId = hostId(nemaHome);
+  const verifier = randomToken();
+  const challenge = b64url(createHash("sha256").update(verifier).digest());
+  const state = randomToken();
+  const nonce = randomToken();
+  const server = createServer();
+  try {
+    const port = await startCallbackServer(server, opts.port);
+    const redirectUri = `http://${SIWC.callbackHost}:${port}${SIWC.callbackPath}`;
+    const params = new URLSearchParams({
+      client_id: savedClientId ?? SIWC.dynamicClientId,
+      ...savedClientId ? {} : { agent_name_hint: SIWC.agentNameHint },
+      ext_agent_host_id: extAgentHostId,
+      response_type: "code",
+      redirect_uri: redirectUri,
+      scope: `${SIWC.identityScopes} ${SIWC.planScopes}`,
+      resource: SIWC.resource,
+      state,
+      nonce,
+      code_challenge_method: "S256",
+      code_challenge: challenge
+    });
+    const authorizeRequestUrl = `${authorizeUrl}?${params.toString()}`;
+    if (opts.requireTrustedAuthorizeUrl) {
+      const url = new URL(authorizeRequestUrl);
+      if (url.protocol !== "https:" || url.hostname !== "auth.openai.com" || url.pathname !== "/api/accounts/authorize" || url.username || url.password || url.port || url.hash) {
+        throw new Error("Untrusted OAuth authorize URL");
+      }
+    }
+    const callback = waitForCallback(server, { state, clientId: savedClientId }, timeoutMs, opts.signal, opts.redactCallbackErrors);
+    try {
+      opts.openBrowser(authorizeRequestUrl);
+    } catch {
+    }
+    const cb = await callback;
+    try {
+      opts.signal?.throwIfAborted();
+      const tokens = await exchangeCode(tokenUrl, {
+        grant_type: "authorization_code",
+        client_id: cb.clientId,
+        code: cb.code,
+        code_verifier: verifier,
+        redirect_uri: redirectUri,
+        resource: SIWC.resource
+      }, opts.signal);
+      const scopes = grantedScopes(tokens, cb.scope);
+      if (!scopes || !scopes.includes(SIWC.planUsageScope)) {
+        throw new Error(`\u767B\u5F55\u5931\u8D25\uFF1A\u672A\u6388\u4E88 ${SIWC.planUsageScope}\uFF08\u8BE5\u8D26\u53F7\u672A\u5141\u8BB8 Nema \u4F7F\u7528 ChatGPT \u5957\u9910\u989D\u5EA6\uFF09\uFF0C\u672A\u4FDD\u5B58\u51ED\u8BC1`);
+      }
+      const accountId = validateIdToken(tokens.id_token, { clientId: cb.clientId, nonce, nowS: Math.floor(Date.now() / 1e3) });
+      const auth = {
+        version: 1,
+        mode: "siwc",
+        clientId: cb.clientId,
+        tokens: {
+          access_token: tokens.access_token,
+          refresh_token: tokens.refresh_token,
+          ...tokens.id_token ? { id_token: tokens.id_token } : {}
+        },
+        accountId,
+        lastRefresh: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await withFileLock(path.join(nemaHome, "auth.lock"), async () => {
+        opts.signal?.throwIfAborted();
+        store.save(auth);
+      }, { timeoutMs: 15e3 });
+      page(cb.res, 200, "Nema Room \u767B\u5F55\u6210\u529F\uFF0C\u53EF\u4EE5\u5173\u95ED\u6B64\u9875\u9762\u5E76\u56DE\u5230\u7EC8\u7AEF\u3002");
+      return auth;
+    } catch (e) {
+      page(cb.res, 500, opts.redactCallbackErrors ? "Login failed. Return to Nema Room settings." : e instanceof Error ? e.message : "\u767B\u5F55\u5931\u8D25");
+      throw e;
+    }
+  } finally {
+    server.closeAllConnections();
+    await new Promise((r) => server.close(() => r()));
+  }
+}
+function makeSiwcRefresher(tokenUrl = SIWC.tokenUrl) {
+  return async (auth, signal) => {
+    if (auth.mode !== "siwc")
+      throw new ReloginRequiredError("mode_mismatch");
+    const res = await fetch(tokenUrl, {
+      method: "POST",
+      headers: { ...nemaHeaders(), "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: auth.tokens.refresh_token,
+        client_id: auth.clientId,
+        resource: SIWC.resource
+        // scope omitted to retain the grant
+      }).toString(),
+      signal
+    });
+    if (!res.ok) {
+      const { code } = await errorCode(res);
+      if (code && UNUSABLE_REFRESH_CODES.includes(code))
+        throw new ReloginRequiredError(code);
+      const ra = Number(res.headers.get("retry-after"));
+      throw new RefreshError(res.status, { code, retryAfterS: Number.isFinite(ra) && ra >= 0 && res.headers.has("retry-after") ? ra : void 0 });
+    }
+    const body = await res.json();
+    if (typeof body.access_token !== "string" || body.access_token === "")
+      throw new Error("\u5237\u65B0\u54CD\u5E94\u7F3A\u5C11 access_token");
+    return {
+      access_token: body.access_token,
+      ...typeof body.refresh_token === "string" && body.refresh_token !== "" ? { refresh_token: body.refresh_token } : {},
+      ...typeof body.id_token === "string" && body.id_token !== "" ? { id_token: body.id_token } : {}
+    };
+  };
+}
+var siwcRefresher = makeSiwcRefresher();
+export {
+  SIWC,
+  UNUSABLE_REFRESH_CODES,
+  cliVersion,
+  hostId,
+  makeSiwcRefresher,
+  nemaHeaders,
+  nemaUserAgent,
+  siwcLogin,
+  siwcRefresher
+};

package/dist/direct/tools.d.ts

@@ -0,0 +1,17 @@
+import { type PluginToolSpec } from "@nema/shared";
+import { type RoomClient } from "../room/client.js";
+import type { FunctionTool } from "./transport.js";
+export type RoomApi = Pick<RoomClient, "listEntries" | "readEntry" | "upsertEntry" | "openThread" | "callPlugin">;
+export declare const ROOM_TOOLS: FunctionTool[];
+/** Claude allowed names for the same functions `roomTools` declares, prefixed `mcp__room__`. */
+export declare function claudeAllowedToolNames(pluginTools: PluginToolSpec[]): string[];
+/** The 4 Room functions, then one non-strict function per plugin tool, in the order the task listed them. */
+export declare function roomTools(pluginTools: PluginToolSpec[]): FunctionTool[];
+/**
+ * Runs one model function call against the Room API. Unknown names and arguments that are not a JSON object
+ * return an error output with `known: false` (the loop counts these) and never reach the hub.
+ */
+export declare function dispatchTool(name: string, argsJson: string, room: RoomApi, pluginTools?: PluginToolSpec[]): Promise<{
+    output: string;
+    known: boolean;
+}>;

package/dist/direct/tools.js

@@ -0,0 +1,104 @@
+import {
+  UpsertEntryInput
+} from "../chunks/chunk-HEIQINX3.js";
+
+// direct/tools.js
+import { z } from "zod";
+import { capText } from "../room/client.js";
+function upsertParameters() {
+  const { $schema: _drop, ...schema } = z.toJSONSchema(UpsertEntryInput);
+  const required = Array.isArray(schema.required) ? schema.required : [];
+  return { ...schema, required: required.includes("basis") ? required : [...required, "basis"] };
+}
+var ROOM_TOOLS = [
+  {
+    type: "function",
+    name: "list_entries",
+    description: "List all entries in the Room knowledge base.",
+    strict: false,
+    parameters: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    type: "function",
+    name: "read_entry",
+    description: "Read one Room entry by id.",
+    strict: false,
+    parameters: { type: "object", properties: { id: { type: "string" } }, required: ["id"], additionalProperties: false }
+  },
+  {
+    type: "function",
+    name: "upsert_entry",
+    description: "Create an entry, or update one when `id` is given. sourceMessages and reason are required.",
+    strict: false,
+    parameters: upsertParameters()
+  },
+  {
+    type: "function",
+    name: "open_thread",
+    description: "Move this conversation into a thread anchored on the current message. When the user asks to compare options or weigh tradeoffs and has not decided, call this first and discuss inside the thread. Your reply will be posted in the thread.",
+    strict: false,
+    parameters: { type: "object", properties: { title: { type: "string" } }, required: ["title"], additionalProperties: false }
+  }
+];
+function claudeAllowedToolNames(pluginTools) {
+  return roomTools(pluginTools).map((tool) => `mcp__room__${tool.name}`);
+}
+function roomTools(pluginTools) {
+  return [
+    ...ROOM_TOOLS,
+    ...pluginTools.map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      strict: false,
+      parameters: tool.parameters
+    }))
+  ];
+}
+var errorOutput = (error, extra = {}) => JSON.stringify({ error, ...extra });
+function resultOutput(r) {
+  if (!r.ok)
+    return capText(errorOutput(r.error, { status: r.status }));
+  return capText(typeof r.json === "string" ? r.json : JSON.stringify(r.json));
+}
+async function dispatchTool(name, argsJson, room, pluginTools = []) {
+  const plugin = pluginTools.find((tool) => tool.name === name);
+  const isRoom = name === "list_entries" || name === "read_entry" || name === "upsert_entry" || name === "open_thread";
+  if (!plugin && !isRoom) {
+    const shown = name.length > 100 ? name.slice(0, 100) + "\u2026" : name;
+    const allowed = ["list_entries", "read_entry", "upsert_entry", "open_thread", ...pluginTools.map((tool) => tool.name)].join("\u3001");
+    return { output: errorOutput(`\u672A\u77E5\u51FD\u6570 ${JSON.stringify(shown)}\uFF1B\u53EA\u80FD\u4F7F\u7528 ${allowed}`), known: false };
+  }
+  let args;
+  try {
+    args = argsJson.trim() === "" ? {} : JSON.parse(argsJson);
+  } catch {
+    return { output: errorOutput(`${name} \u7684\u53C2\u6570\u4E0D\u662F\u5408\u6CD5\u7684 JSON`), known: false };
+  }
+  if (!args || typeof args !== "object" || Array.isArray(args)) {
+    return { output: errorOutput(`${name} \u7684\u53C2\u6570\u5FC5\u987B\u662F JSON \u5BF9\u8C61`), known: false };
+  }
+  if (plugin)
+    return { output: resultOutput(await room.callPlugin(name, args)), known: true };
+  switch (name) {
+    case "list_entries":
+      return { output: resultOutput(await room.listEntries()), known: true };
+    case "read_entry": {
+      const id = args.id;
+      if (typeof id !== "string" || id === "")
+        return { output: errorOutput("read_entry \u9700\u8981\u5B57\u7B26\u4E32\u53C2\u6570 id"), known: true };
+      return { output: resultOutput(await room.readEntry(id)), known: true };
+    }
+    case "upsert_entry":
+      return { output: resultOutput(await room.upsertEntry(args)), known: true };
+    case "open_thread":
+      return { output: resultOutput(await room.openThread(args)), known: true };
+  }
+  throw new Error(`unreachable tool ${name}`);
+}
+export {
+  ROOM_TOOLS,
+  claudeAllowedToolNames,
+  dispatchTool,
+  roomTools
+};