mixdog 1.4.1 → 1.4.3

package/src/runtime/connectors/connector-accounts-mcp.mjs

@@ -1,20 +1,36 @@
-// The one MCP server of a multi-account connector (connector-catalog.mjs
-// connectorAccountsOf): Gmail, Google Calendar or Google Drive with every
-// connected account behind one tool set. Answered in-process like the
-// one-account servers it fronts (google-mcp.mjs, gmail-app-password.mjs):
-// each tool takes `account` (the account's address), and the call goes to
-// that account's own endpoint with that account's own credentials (its OAuth
-// tokens, or its app password from the keychain). With one account
-// `account` may be left out; with several, a call naming none is refused
-// with the list, so the model asks the user. An account that fails stays
-// listed with why (connectorAccountHealth); the server only fails to start
-// when no account can be used.
+// The one MCP server of a catalog connector (connector-catalog.mjs
+// connectorAccountsOf): every connected account of Gmail, Notion, Postgres…
+// behind one tool set, answered in-process. Underneath, each account is its
+// own ordinary MCP connection with its own credentials (client-transport.mjs
+// connectorAccountClient), and its tools are the ones its backend lists. This
+// server lists their union (a tool whose schema differs between accounts is
+// left out), each with one more optional argument, `account` (an account's
+// address or name), which never reaches the account.
+//
+// The account a call uses: the one it names; else the one last used in its
+// conversation, else the connector's last-used account (connectorAccountInUse),
+// else the topmost connected account. A named or remembered account that is
+// switched off, removed or needs a sign-in fails the call with the usable
+// accounts listed; no other account ever stands in for it, a new account
+// given a removed one's name included (a remembered account is bound to its
+// identity, not its name). A conversation's
+// call (`_meta[CONVERSATION_META]`) makes its account the last used, for the
+// conversation and the connector. Every result of a call made on an account,
+// errors included, says which account answered. A name binds a call to one
+// account; an address or label two accounts share binds none.
+// An account that fails stays listed with why (connectorAccountHealth); the
+// server only fails to start when no account can be used.
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { readJsonStateSync, updateJsonAtomicSync } from '../shared/atomic-file.mjs';
+import { readSection, updateSection } from '../shared/config.mjs';
 import { accountsOfInstructions, connectorAccountsInstructions } from '../shared/connector-accounts.mjs';
-import { connectorById } from '../shared/connector-catalog.mjs';
-import { gmailAppPasswordTools } from './gmail-app-password.mjs';
-import { googleMcpTools } from './google-mcp.mjs';
+import { connectorAccountsOf, connectorById, connectorOfServer } from '../shared/connector-catalog.mjs';
+import { resolvePluginData } from '../shared/plugin-paths.mjs';
 
 const PROTOCOL_VERSION = '2025-06-18';
+/** The `_meta` key of a tools/call that names the conversation it is made in. */
+export const CONVERSATION_META = 'mixdog/conversation';
 
 const json = (status, body) =>
   new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
@@ -36,66 +52,289 @@ export function forgetConnectorAccountHealth(name) {
   health.delete(name);
 }
 
-const ACCOUNT_PROPERTY = Object.freeze({
-  type: 'string',
-  description:
-    'The account to act as (its email address). May be left out when one account is connected; required when several are.',
-});
+// ── The last-used account ───────────────────────────────────────────────────
+// Per connector and per conversation, in the data dir (every runtime and every
+// restart reads the same ones).
+const ACCOUNTS_IN_USE_FILE = 'connector-accounts-in-use.json';
+const inUseFile = () => join(resolvePluginData(), ACCOUNTS_IN_USE_FILE);
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const validInUse = (value) => {
+  if (!isRecord(value)) throw new Error('the accounts in use must be an object');
+  return value;
+};
 
-const SERVICE_OF = { gmail: 'gmail', 'google-calendar': 'calendar', 'google-drive': 'drive' };
-
-/** The tools of `connector` over `accounts`, each taking `account`. Gmail on
- *  an app password has the larger set (IMAP); a Google sign-in Gmail account
- *  answers the tools it has and refuses the others. */
-function connectorTools(connector, accounts, { hidden = false } = {}) {
-  const tools =
-    connector === 'gmail' && accounts.some((account) => account.appPassword)
-      ? gmailAppPasswordTools({ hidden })
-      : googleMcpTools(SERVICE_OF[connector]);
-  return tools.map((tool) => ({
-    ...tool,
-    inputSchema: {
-      ...tool.inputSchema,
-      properties: { ...(tool.inputSchema?.properties || {}), account: ACCOUNT_PROPERTY },
-    },
+// A remembered account is `{ name, id }`: the name it was called by and its
+// identity (connector-catalog.mjs connectorAccountId: the random id stored
+// with it). A name can be given to a new account once the old one is
+// removed; the identity cannot, so it binds the choice to the account.
+const readInUse = () => readJsonStateSync(inUseFile(), { validate: validInUse, fallback: {} });
+
+// Set in the accounts-in-use file once its name-only records (from before
+// identities) were bound to the accounts then under those names.
+const IDS_MIGRATED = '#ids';
+
+const hasId = (account) => typeof account?.id === 'string' && account.id !== '';
+const missingIds = (servers) =>
+  Object.values(isRecord(servers) ? servers : {}).some((cfg) => connectorAccountsOf(cfg).some((one) => !hasId(one)));
+
+/** Test seam: runs once the config lock that gave the ids is released, before
+ *  the binding (where another process's write may land). */
+export const accountIdsDeps = { afterIdsGiven: () => {} };
+
+/** `servers` with a random id given to every connector account stored
+ *  without one; null when every account has one. */
+function withAccountIds(servers) {
+  if (!missingIds(servers)) return null;
+  return Object.fromEntries(
+    Object.entries(servers).map(([name, cfg]) => {
+      if (!connectorAccountsOf(cfg).some((one) => !hasId(one))) return [name, cfg];
+      const accounts = cfg.accounts.map((account) =>
+        isRecord(account) && !hasId(account) ? { ...account, id: randomUUID() } : account
+      );
+      return [name, { ...cfg, accounts }];
+    })
+  );
+}
+
+/**
+ * Every stored connector account gets an identity, once, at every start and
+ * after a config change (an account written by hand has none). All under the
+ * accounts-in-use file's lock, so concurrent runs (processes, runtimes) and
+ * choices serialize: the config is changed only where an id is missing (an id
+ * once given is never replaced), and the first run also binds each name-only
+ * record (from before identities) to the account then under that name, which
+ * is where such a record routed until now, and marks that done. A name-only
+ * record found afterwards stays unbound (it fails closed). Records already
+ * holding an identity are never touched. True when it changed the config.
+ *
+ * The binding uses the accounts exactly as the ids were given or confirmed:
+ * the config is re-read nowhere after that, so an account replaced under the
+ * same name meanwhile (by another process) is never the one bound; it fails
+ * the identity check instead.
+ */
+export function ensureConnectorAccountIds() {
+  let changed = false;
+  updateJsonAtomicSync(inUseFile(), (current) => {
+    const stored = isRecord(current) ? current : {};
+    // The stored servers whose ids the binding below uses.
+    let snapshot = readSection('agent')?.mcpServers;
+    if (missingIds(snapshot)) {
+      updateSection('agent', (agent) => {
+        const servers = withAccountIds(agent.mcpServers);
+        snapshot = servers ?? agent.mcpServers;
+        if (!servers) return agent;
+        changed = true;
+        return { ...agent, mcpServers: servers };
+      });
+      accountIdsDeps.afterIdsGiven();
+    }
+    if (stored[IDS_MIGRATED]) return undefined;
+    const servers = Object.values(isRecord(snapshot) ? snapshot : {});
+    const next = { ...stored, [IDS_MIGRATED]: true };
+    for (const [connector, name] of Object.entries(stored)) {
+      if (typeof name !== 'string' || !name) continue;
+      const cfg = servers.find((one) => connectorOfServer(one) === connector && connectorAccountsOf(one).length);
+      const account = cfg && connectorAccountsOf(cfg).find((one) => one.name === name);
+      if (hasId(account)) next[connector] = { name, id: account.id };
+    }
+    return next;
+  });
+  return changed;
+}
+
+/** The account catalog connector `connector` used last, null when none was
+ *  recorded. A name-only record (from before identities, unbound) has an
+ *  empty `id`. */
+export function connectorAccountInUseRecord(connector) {
+  const value = readInUse()[connector];
+  if (typeof value === 'string') return value ? { name: value, id: '' } : null;
+  if (!isRecord(value) || typeof value.name !== 'string' || !value.name) return null;
+  return { name: value.name, id: typeof value.id === 'string' ? value.id : '' };
+}
+
+/** The name of the account catalog connector `connector` used last, '' when
+ *  none was recorded. */
+export function connectorAccountInUse(connector) {
+  return connectorAccountInUseRecord(connector)?.name || '';
+}
+
+function rememberAccountInUse(connector, account) {
+  const current = connectorAccountInUseRecord(connector);
+  if (current?.name === account.name && current.id === account.id) return;
+  updateJsonAtomicSync(inUseFile(), (stored) => ({
+    ...(isRecord(stored) ? stored : {}),
+    [connector]: { name: account.name, id: account.id },
   }));
 }
 
-class AccountChoiceError extends Error {}
+// Per conversation, in the data dir too, so a conversation resumed after a
+// restart keeps its own account: conversation (its session id) → { accounts:
+// (connector → { name, id }) }. A binding lives as long as its session: it is
+// dropped only when the session is deleted (forgetConversationConnectorAccounts,
+// a session purge hook), never to make room, so no live conversation falls
+// back to another conversation's choice.
+const CONVERSATION_ACCOUNTS_FILE = 'connector-accounts-by-conversation.json';
+const conversationsFile = () => join(resolvePluginData(), CONVERSATION_ACCOUNTS_FILE);
 
-const labelOf = (account) => account.email || account.name;
+/** Drop the connector accounts conversation `conversation` used (its session
+ *  was deleted). */
+export function forgetConversationConnectorAccounts(conversation) {
+  const id = text(conversation);
+  if (!id || !Object.hasOwn(readJsonStateSync(conversationsFile(), { validate: validInUse, fallback: {} }), id)) return;
+  updateJsonAtomicSync(conversationsFile(), (stored) => {
+    const { [id]: _gone, ...rest } = isRecord(stored) ? stored : {};
+    return rest;
+  });
+}
 
-/** The account a call names (by address, or by its account name), or its
- *  only account; throws the account list otherwise. */
-function pickAccount(accounts, value, service) {
-  const list = accounts.map(labelOf).join(', ');
-  const wanted = text(value).toLowerCase();
-  if (wanted) {
-    const found = accounts.find(
-      (account) => account.email.toLowerCase() === wanted || account.name.toLowerCase() === wanted
-    );
-    if (!found) throw new AccountChoiceError(`Unknown ${service} account "${text(value)}". Accounts: ${list}.`);
-    return found;
+/** The account conversation `conversation` used last on `connector`, or null. */
+function conversationAccount(conversation, connector) {
+  const own = readJsonStateSync(conversationsFile(), { validate: validInUse, fallback: {} })[conversation];
+  const value = isRecord(own?.accounts) ? own.accounts[connector] : null;
+  if (!isRecord(value) || typeof value.name !== 'string' || !value.name) return null;
+  return { name: value.name, id: typeof value.id === 'string' ? value.id : '' };
+}
+
+function rememberConversationAccount(conversation, connector, account) {
+  const current = conversationAccount(conversation, connector);
+  if (current?.name === account.name && current.id === account.id) return;
+  updateJsonAtomicSync(conversationsFile(), (stored) => {
+    const all = isRecord(stored) ? stored : {};
+    const accounts = isRecord(all[conversation]?.accounts) ? all[conversation].accounts : {};
+    return {
+      ...all,
+      [conversation]: { accounts: { ...accounts, [connector]: { name: account.name, id: account.id } } },
+    };
+  });
+}
+
+const ACCOUNT_PROPERTY = Object.freeze({
+  type: 'string',
+  description: 'The account to use (its email address or account name). Left out: the account used last.',
+});
+
+/** `value` as JSON with every object's keys sorted, so equal schemas compare
+ *  equal whatever order their keys were written in. */
+const canonical = (value) => {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
+  if (isRecord(value)) {
+    const keys = Object.keys(value)
+      .filter((key) => value[key] !== undefined)
+      .sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
   }
-  if (accounts.length === 1) return accounts[0];
-  throw new AccountChoiceError(
-    `Several ${service} accounts are connected: ${list}. Ask the user which one, then pass it as \`account\`.`
-  );
+  return JSON.stringify(value) ?? 'null';
+};
+
+/** The tools every account lists, once each, with `account` added; a tool
+ *  two accounts list with different schemas is left out. */
+function unionTools(states) {
+  const first = new Map();
+  const differs = new Set();
+  for (const { tools = [] } of states) {
+    for (const tool of tools) {
+      const seen = first.get(tool.name);
+      if (!seen) first.set(tool.name, tool);
+      else if (canonical(seen.inputSchema) !== canonical(tool.inputSchema)) differs.add(tool.name);
+    }
+  }
+  return [...first.values()]
+    .filter((tool) => !differs.has(tool.name))
+    .map((tool) => ({
+      ...tool,
+      inputSchema: {
+        type: 'object',
+        ...tool.inputSchema,
+        properties: { ...(tool.inputSchema?.properties || {}), account: ACCOUNT_PROPERTY },
+      },
+    }));
 }
 
 const noteOf = (state) => (state.authRequired ? 'needs sign-in' : 'unavailable');
+const usable = (account) => health.get(account.name)?.authRequired !== true;
+
+/** `result` saying which account answered it (`label`). */
+const withAccountNote = (result, service, label) => ({
+  ...result,
+  content: [
+    ...(Array.isArray(result?.content) ? result.content : []),
+    { type: 'text', text: `(${service} account: ${label})` },
+  ],
+});
 
 /**
  * A `fetch` answering the accounts server of `connector` in-process. Each of
- * `accounts` is `{ name, email, appPassword, request(message, { signal }) }`:
- * `request` sends one JSON-RPC message to that account's own endpoint with its own
- * credentials and resolves the JSON-RPC reply; it throws when the account
- * cannot be reached (an `authRequired` error when it needs a sign-in).
+ * `accounts` is `{ name, id, email, connect(signal), callTool(params, { signal, onprogress }) }`
+ * (`id`: its identity, connector-catalog.mjs connectorAccountId):
+ * `connect` resolves `{ instructions, tools }` of that account's own MCP
+ * connection, `callTool` sends it one tools/call (reporting its progress to
+ * `onprogress`, when given) and resolves the result; both
+ * throw when the account cannot be reached (an `authRequired` error when it
+ * needs a sign-in). The fetch carries `connectorAccounts`: `{ connector,
+ * choose({ tool, wanted, conversation }) }`, `{ name, label }` of the account
+ * such a call would use (it throws the refusal otherwise), for binding a call
+ * to its account (by its unique name) before it is approved.
  */
 export function withConnectorAccountsMcp({ connector, accounts }) {
   const service = connectorById(connector)?.name || connector;
-  const listed = connectorTools(connector, accounts);
-  const callable = connectorTools(connector, accounts, { hidden: true });
+  // account name → the names of the tools it lists (set once it answered).
+  const toolsOf = new Map();
+  let listed = [];
+  const same = (a, b) => Boolean(a) && a.toLowerCase() === b.toLowerCase();
+  /** What an account is called to the model: its address, with its name when
+   *  another account shares that address. */
+  const labelOf = (account) => {
+    if (!account.email) return account.name;
+    const shared = accounts.some((other) => other !== account && same(other.email, account.email));
+    return shared ? `${account.email} (${account.name})` : account.email;
+  };
+  /** The account a call uses (see the header); throws the refusal. */
+  const choose = ({ tool, wanted, conversation }) => {
+    const refuse = (why) => {
+      const list = accounts.filter(usable).map(labelOf).join(', ') || 'none';
+      return new Error(`${why} Usable ${service} accounts: ${list}. Pass one as \`account\`.`);
+    };
+    const named = text(wanted);
+    let account;
+    if (named) {
+      // Its unique name, else the one account its address or label is.
+      let matches = accounts.filter((one) => same(one.name, named));
+      if (!matches.length) matches = accounts.filter((one) => same(one.email, named) || same(labelOf(one), named));
+      if (!matches.length) throw refuse(`No connected ${service} account is "${named}".`);
+      if (matches.length > 1) {
+        const names = matches.map((one) => one.name).join(', ');
+        throw refuse(`"${named}" is more than one ${service} account (${names}); name one.`);
+      }
+      [account] = matches;
+    } else {
+      const remembered =
+        (conversation && conversationAccount(conversation, connector)) || connectorAccountInUseRecord(connector);
+      if (remembered) {
+        account = accounts.find((one) => one.name === remembered.name);
+        // The name must still be the account it named: one removed and its
+        // name given to a new account, or a record without an identity (one
+        // ensureConnectorAccountIds did not bind, or an account picked before
+        // it had an id), fails closed until an account is picked again.
+        if (account && !remembered.id) {
+          throw refuse(
+            `The ${service} account used last (${remembered.name}) cannot be confirmed as the same account.`
+          );
+        }
+        if (account && account.id !== remembered.id) {
+          throw refuse(`The ${service} account used last (${remembered.name} (removed)) is not connected now.`);
+        }
+        if (!account) throw refuse(`The ${service} account used last (${remembered.name}) is not connected now.`);
+      } else {
+        account = accounts[0];
+      }
+    }
+    if (!usable(account)) throw refuse(`${labelOf(account)} needs a sign-in in Connectors.`);
+    const has = toolsOf.get(account.name);
+    if (has && !has.has(tool) && listed.some((one) => one.name === tool)) {
+      throw refuse(`${labelOf(account)} has no ${tool} tool.`);
+    }
+    return account;
+  };
   const record = (account, state) => {
     if (state.email) account.email = state.email;
     health.set(account.name, {
@@ -109,13 +348,13 @@ export function withConnectorAccountsMcp({ connector, accounts }) {
     record(account, state);
     return state;
   };
-  // Each account's own initialize: whether it can be used, and its address.
+  // Each account's own connection: whether it can be used, its address and tools.
   const probe = async (account, signal) => {
     try {
-      const reply = await account.request({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} }, { signal });
-      if (reply?.error) return failure(account, new Error(reply.error.message || 'The account did not start'));
-      const [email = ''] = accountsOfInstructions(reply?.result?.instructions);
-      const state = { email: account.email || email };
+      const { instructions, tools } = await account.connect(signal);
+      toolsOf.set(account.name, new Set(tools.map((tool) => tool.name)));
+      const [email = ''] = accountsOfInstructions(instructions);
+      const state = { email: account.email || email, instructions, tools };
       record(account, state);
       return state;
     } catch (error) {
@@ -125,7 +364,9 @@ export function withConnectorAccountsMcp({ connector, accounts }) {
   // The calls in flight by JSON-RPC id, so a `notifications/cancelled` for one
   // aborts its downstream request.
   const inflight = new Map();
-  async function rpc(message, transportSignal) {
+  /** One JSON-RPC request's reply; `notify` sends a notification ahead of it
+   *  (a tools/call's progress). */
+  async function rpc(message, transportSignal, notify = null) {
     const { id, method, params } = message || {};
     const reply = (result) => ({ jsonrpc: '2.0', id, result });
     if (method === 'initialize') {
@@ -138,55 +379,70 @@ export function withConnectorAccountsMcp({ connector, accounts }) {
           error: { code: -32001, message: first?.error || `No ${service} account is connected` },
         };
       }
+      listed = unionTools(states);
+      // What the accounts' own servers tell the model (an in-process Google
+      // account's only names its address, which the account list says).
+      const own = [
+        ...new Set(
+          states.map((state) => text(state.instructions)).filter((one) => one && !accountsOfInstructions(one).length)
+        ),
+      ];
+      const accountsLine = connectorAccountsInstructions(
+        accounts.map((account, index) => ({
+          email: labelOf(account),
+          ...(states[index].error ? { note: noteOf(states[index]) } : {}),
+        }))
+      );
       return reply({
         protocolVersion: text(params?.protocolVersion) || PROTOCOL_VERSION,
         capabilities: { tools: { listChanged: false } },
         serverInfo: { name: `mixdog-${connector}`, version: '1.0.0' },
-        instructions: connectorAccountsInstructions(
-          accounts.map((account, index) => ({
-            email: labelOf(account),
-            ...(states[index].error ? { note: noteOf(states[index]) } : {}),
-          }))
-        ),
+        instructions: [accountsLine, ...own].filter(Boolean).join('\n\n') || undefined,
       });
     }
     if (method === 'ping') return reply({});
     if (method === 'tools/list') return reply({ tools: listed });
     if (method === 'tools/call') {
       const name = params?.name;
-      if (!callable.some((tool) => tool.name === name)) {
-        return { jsonrpc: '2.0', id, error: { code: -32602, message: `Unknown tool: ${name}` } };
-      }
-      const { account: chosen, ...args } = params?.arguments || {};
+      const { account: wanted, ...args } = params?.arguments || {};
+      const conversation = text(params?._meta?.[CONVERSATION_META]);
       let account;
       try {
-        account = pickAccount(accounts, chosen, service);
+        account = choose({ tool: name, wanted, conversation });
+        if (conversation) {
+          rememberConversationAccount(conversation, connector, account);
+          rememberAccountInUse(connector, account);
+        }
       } catch (error) {
-        return reply(errorResult(error.message));
+        return reply(errorResult(error?.message || String(error)));
       }
       const cancel = new AbortController();
       const signal = transportSignal ? AbortSignal.any([transportSignal, cancel.signal]) : cancel.signal;
       inflight.set(id, cancel);
+      // The account's progress reaches the caller under the caller's own token,
+      // so it resets the call's deadline as a direct server's progress does.
+      const progressToken = params?._meta?.progressToken;
+      const onprogress =
+        notify && progressToken !== undefined
+          ? (progress) =>
+              notify({ jsonrpc: '2.0', method: 'notifications/progress', params: { ...progress, progressToken } })
+          : undefined;
       try {
-        const answer = await account.request(
-          { jsonrpc: '2.0', id, method, params: { name, arguments: args } },
-          { signal }
-        );
-        if (answer?.error) return reply(errorResult(`${labelOf(account)}: ${answer.error.message}`));
+        // An unlisted tool (one only the approval gate calls) is the account's to answer.
+        const result = await account.callTool({ name, arguments: args }, { signal, onprogress });
         if (health.get(account.name)?.error) record(account, {});
-        return reply(answer?.result ?? errorResult(`${labelOf(account)}: no answer`));
+        return reply(withAccountNote(result, service, labelOf(account)));
       } catch (error) {
         // A cancelled call says nothing about the account's health.
-        if (signal.aborted) return reply(errorResult(`${labelOf(account)}: cancelled`));
-        const state = failure(account, error);
-        return reply(errorResult(`${labelOf(account)}: ${state.error}`));
+        const why = signal.aborted ? 'cancelled' : failure(account, error).error;
+        return reply(withAccountNote(errorResult(why), service, labelOf(account)));
       } finally {
         inflight.delete(id);
       }
     }
     return { jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${method}` } };
   }
-  return async (input, init) => {
+  const fetchImpl = async (input, init) => {
     const request = input instanceof Request ? input : null;
     if (String(request?.method || init?.method || 'GET').toUpperCase() !== 'POST') {
       return new Response(null, { status: 405, headers: { allow: 'POST' } });
@@ -203,28 +459,41 @@ export function withConnectorAccountsMcp({ connector, accounts }) {
     for (const one of batch) {
       if (one?.method === 'notifications/cancelled') inflight.get(one.params?.requestId)?.abort();
     }
+    // A call asking for progress is answered as an event stream: its progress
+    // notifications, then its reply.
+    if (!Array.isArray(message) && message?.id !== undefined && message.params?._meta?.progressToken !== undefined) {
+      const encoder = new TextEncoder();
+      let open = true;
+      const stream = new ReadableStream({
+        start(controller) {
+          const send = (payload) => {
+            if (open) controller.enqueue(encoder.encode(`event: message\ndata: ${JSON.stringify(payload)}\n\n`));
+          };
+          void rpc(message, signal, send).then((answer) => {
+            send(answer);
+            if (open) controller.close();
+            open = false;
+          });
+        },
+        // The caller stopped reading (its call was aborted).
+        cancel() {
+          open = false;
+        },
+      });
+      return new Response(stream, { status: 200, headers: { 'content-type': 'text/event-stream' } });
+    }
     const replies = (await Promise.all(batch.map((one) => (one?.id === undefined ? null : rpc(one, signal))))).filter(
       Boolean
     );
     if (!replies.length) return new Response(null, { status: 202 });
     return json(200, Array.isArray(message) ? replies : replies[0]);
   };
-}
-
-/** `request` for an account answered at `url` through `fetchImpl` (its
- *  credentials applied there) with `headers`: one JSON-RPC POST, its reply. */
-export function connectorAccountRequest(url, fetchImpl, headers = {}) {
-  return async (message, { signal } = {}) => {
-    const response = await fetchImpl(url, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json', accept: 'application/json, text/event-stream', ...headers },
-      body: JSON.stringify(message),
-      signal,
-    });
-    if (!response.ok) {
-      await response.body?.cancel();
-      throw new Error(`The account's server answered ${response.status}`);
-    }
-    return response.json();
+  fetchImpl.connectorAccounts = {
+    connector,
+    choose: (call) => {
+      const account = choose(call);
+      return { name: account.name, label: labelOf(account) };
+    },
   };
+  return fetchImpl;
 }

package/src/runtime/connectors/gmail-app-password.mjs

@@ -7,7 +7,7 @@
 // for each call. The password is checked with Gmail before it is saved, and
 // never appears in a config, log, error or tool result.
 import { createHash } from 'node:crypto';
-import keychain from '../../lib/keychain-cjs.cjs';
+import { keychainSecretStore as keychain } from '../shared/config.mjs';
 import { GMAIL_APP_PASSWORD, gmailAddress } from '../shared/connector-catalog.mjs';
 import { connectorAccountsInstructions } from '../shared/connector-accounts.mjs';
 
@@ -723,9 +723,9 @@ const TOOLS = [
 ];
 
 /** The tool definitions (name, description, schema, annotations) the server
- *  lists; with `hidden`, also the ones only the approval gate calls. */
-export function gmailAppPasswordTools({ hidden = false } = {}) {
-  return TOOLS.filter((tool) => hidden || !tool.hidden).map(({ run, hidden: _hidden, ...tool }) => tool);
+ *  lists: never the ones only the approval gate calls. */
+function gmailAppPasswordTools() {
+  return TOOLS.filter((tool) => !tool.hidden).map(({ run, hidden: _hidden, ...tool }) => tool);
 }
 
 // ── The MCP server at the reserved address ──────────────────────────────────

package/src/runtime/connectors/google-mcp.mjs

@@ -331,7 +331,7 @@ const SERVICES = {
 
 /** The tool definitions (name, description, schema, annotations) of built-in
  *  Google service `service` (`gmail`, `calendar`, `drive`). */
-export function googleMcpTools(service) {
+function googleMcpTools(service) {
   return (SERVICES[service]?.tools || []).map(({ run, ...tool }) => tool);
 }
 

package/src/runtime/effort-judge/judge-client.mjs

@@ -83,7 +83,7 @@ function waitReady(ms) {
   });
 }
 
-export function effortJudgeModelDir() {
+function effortJudgeModelDir() {
   return process.env.MIXDOG_EFFORT_JUDGE_DIR || join(resolvePluginData(), 'models', 'effort-judge');
 }
 
@@ -280,7 +280,7 @@ async function runInstall() {
  * background. Runs on the first judged turn of the process, never at runtime
  * creation, so booting touches no network.
  */
-export function refreshEffortJudge() {
+function refreshEffortJudge() {
   if (!onnxRuntimeSupported()) return;
   installEffortJudge().catch((error) => {
     // An older complete install still works.

package/src/runtime/effort-judge/judge-input.mjs

@@ -17,7 +17,7 @@ const HEX = /(?<![0-9A-Za-z])[0-9a-fA-F]{12,}(?![0-9A-Za-z])/g;
 const SPACES = /[ \t]+/g;
 const BLANK_LINES = /\n[ \t]*\n[\n \t]*/g;
 
-export function cleanJudgeText(text) {
+function cleanJudgeText(text) {
   return String(text || '')
     .replace(/\r\n?/g, '\n')
     .replace(ANSI, '')
@@ -49,10 +49,10 @@ export function judgeInputClean(request, prev) {
 // continues), the previous reply's first line (its topic), then as much of the
 // reply's END (what a short approval answers) as remains. Training builds the
 // same id sequence (clean_text.pack_ids) with the identical tokenizer.
-export const PACK_BUDGET = Object.freeze({ request: 64, prevRequest: 24, replyHead: 16 });
+const PACK_BUDGET = Object.freeze({ request: 64, prevRequest: 24, replyHead: 16 });
 
 /** Split the cleaned previous reply into its first line and the remaining text. */
-export function splitReply(reply) {
+function splitReply(reply) {
   const at = reply.indexOf('\n');
   return at < 0 ? [reply, ''] : [reply.slice(0, at), reply.slice(at + 1)];
 }
@@ -63,7 +63,7 @@ export function splitReply(reply) {
 // A result keeps its start and end (where errors and summaries sit); the
 // stored window (2000 + 1000 code points) bounds the cleaning work on huge
 // outputs. Training builds the same text (clean_text.step_judge_text).
-export const STEP_CALLS = 3;
+const STEP_CALLS = 3;
 
 export function stepResultWindow(text) {
   const cps = Array.from(String(text ?? ''));