@falkenslab/agent-kit 0.25.0 → 0.26.0

package/dist/chat/extensions.js

@@ -120,6 +120,11 @@ export async function chatExtensionsCommand(line, status, canReopen) {
         const lines = [status?.active.length ? t().extensionsRunning(status.active.join(", ")) : t().extensionsNone];
         if (status)
             lines.push(...describeCapabilities(status), ...(await needingSignIn(status)).map((extension) => t().extensionNeedsSignIn(extension)));
+        // The claude.ai connectors the agent lets in, apart from installed extensions (#70).
+        if (status?.connectors?.allowed.length)
+            lines.push(t().connectorsAllowed(status.connectors.allowed.map((name) => name.replace(/^claude\.ai /, "")).join(", ")));
+        if (status?.connectors?.missing.length)
+            lines.push(t().connectorsMissing(status.connectors.missing.join(", ")));
         for (const { name: off, reason } of status?.inactive ?? [])
             lines.push(t().extensionOff(off, reason));
         if (status?.installed.length)

package/dist/core/agentSpec.d.ts

@@ -44,6 +44,22 @@ export interface BaseSessionConfig {
      * catalog and `extension search` show only those with one of them. Without it, every one.
      */
     catalogTopics?: string[];
+    /**
+     * The claude.ai connectors of the person's account this agent lets in (#70), by the name
+     * claude.ai shows them (`["Canva", "Notion"]`, any case): those already signed in on claude.ai,
+     * nothing to install. None by default: the kit keeps them out, since they're the account's
+     * integrations, not the agent's. When the session opens, the kit asks the account which it has
+     * (a few seconds) and lets in only these; one asked for that isn't there is said in `/extensions`.
+     */
+    claudeAiConnectors?: string[];
+    /**
+     * What a call to a remote MCP server does (#70): an installed extension's `http`/`sse` server, one
+     * of the agent's own, or a claude.ai connector. What the model sends one leaves the computer, so
+     * an agent handling sensitive data (students') may keep it from them. `"allow"` (the default)
+     * lets it go on; `"ask"` asks the person before each call, saying where it goes (blocked when no
+     * one can be asked, as in autonomous mode); `"deny"` blocks it.
+     */
+    remoteServers?: "allow" | "ask" | "deny";
     /**
      * Directories where the agent reads, searches and writes with the file tools (Write/Edit,
      * scoped — see hooks/fileScopeGate.ts), e.g. a folder of its own notes. Setting one gives the

package/dist/core/claudeAiConnectors.d.ts

@@ -0,0 +1,35 @@
+import { type Options } from "@anthropic-ai/claude-agent-sdk";
+/**
+ * The claude.ai connectors an agent lets in (#70): the person's account's integrations (Canva,
+ * Notion…), which the kit keeps out by default (`disableClaudeAiConnectors`, ADR-018). The SDK
+ * lets them in all or none, and lets one out only by its name (`deniedMcpServers`); an allowlist
+ * would have to list every other server of the session exactly (confirmed empirically, CLI
+ * 2.1.300). So the kit asks the account which it has, when the session opens, and denies by name
+ * the ones the agent didn't choose; a gate blocks a call to any other (one added since).
+ *
+ * `toggleMcpServer()` is never used for them: it saves the switch in the person's own Claude Code
+ * config for the folder (`~/.claude.json`, `disabledMcpServers`), not only in the session
+ * (confirmed empirically, CLI 2.1.300).
+ */
+/** The name the SDK gives a claude.ai connector's server: `claude.ai <Name>`. */
+export declare const CONNECTOR_PREFIX = "claude.ai ";
+/** The prefix of a server's tools as the model names them: `claude.ai Claude Docs` → `mcp__claude_ai_Claude_Docs__`. */
+export declare function serverToolPrefix(server: string): string;
+/** Whether a tool is a claude.ai connector's. */
+export declare function isConnectorTool(tool: string): boolean;
+/** What the agent chose, set against what the account has: the servers to let in, to deny, and the names it asked for that aren't there. */
+export interface ConnectorChoice {
+    allowed: string[];
+    denied: string[];
+    missing: string[];
+}
+/** Chooses among the account's connectors (`found`, as the SDK names them) the ones the agent wants, by the name claude.ai shows (any case). */
+export declare function chooseConnectors(found: readonly string[], wanted: readonly string[]): ConnectorChoice;
+/**
+ * The account's claude.ai connectors, by the names the SDK gives them: a session that sends no
+ * message, opened in `cwd` with connectors on, its servers' status read and closed. A few seconds;
+ * an empty list when it can't tell (no login, no network), so nothing is let in.
+ */
+export declare function discoverConnectors(cwd: string, options?: Pick<Options, "pathToClaudeCodeExecutable" | "env"> & {
+    timeoutMs?: number;
+}): Promise<string[]>;

package/dist/core/claudeAiConnectors.js

@@ -0,0 +1,76 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+/**
+ * The claude.ai connectors an agent lets in (#70): the person's account's integrations (Canva,
+ * Notion…), which the kit keeps out by default (`disableClaudeAiConnectors`, ADR-018). The SDK
+ * lets them in all or none, and lets one out only by its name (`deniedMcpServers`); an allowlist
+ * would have to list every other server of the session exactly (confirmed empirically, CLI
+ * 2.1.300). So the kit asks the account which it has, when the session opens, and denies by name
+ * the ones the agent didn't choose; a gate blocks a call to any other (one added since).
+ *
+ * `toggleMcpServer()` is never used for them: it saves the switch in the person's own Claude Code
+ * config for the folder (`~/.claude.json`, `disabledMcpServers`), not only in the session
+ * (confirmed empirically, CLI 2.1.300).
+ */
+/** The name the SDK gives a claude.ai connector's server: `claude.ai <Name>`. */
+export const CONNECTOR_PREFIX = "claude.ai ";
+/** The prefix of a server's tools as the model names them: `claude.ai Claude Docs` → `mcp__claude_ai_Claude_Docs__`. */
+export function serverToolPrefix(server) {
+    return `mcp__${server.replace(/[^A-Za-z0-9_-]/g, "_")}__`;
+}
+/** Whether a tool is a claude.ai connector's. */
+export function isConnectorTool(tool) {
+    // `claude.ai <Name>` becomes `mcp__claude_ai_<Name>__`: the prefix up to the name.
+    return tool.startsWith("mcp__claude_ai_");
+}
+/** Chooses among the account's connectors (`found`, as the SDK names them) the ones the agent wants, by the name claude.ai shows (any case). */
+export function chooseConnectors(found, wanted) {
+    const label = (server) => (server.startsWith(CONNECTOR_PREFIX) ? server.slice(CONNECTOR_PREFIX.length) : server).toLowerCase();
+    const asked = new Set(wanted.map(label));
+    const allowed = found.filter((server) => asked.has(label(server)));
+    const present = new Set(allowed.map(label));
+    return { allowed, denied: found.filter((server) => !asked.has(label(server))), missing: wanted.filter((name) => !present.has(label(name))) };
+}
+/**
+ * The account's claude.ai connectors, by the names the SDK gives them: a session that sends no
+ * message, opened in `cwd` with connectors on, its servers' status read and closed. A few seconds;
+ * an empty list when it can't tell (no login, no network), so nothing is let in.
+ */
+export async function discoverConnectors(cwd, options = {}) {
+    let release = () => { };
+    const done = new Promise((resolve) => (release = resolve));
+    // A conversation that never sends a message, ended when the look is over: the session only starts its servers.
+    const prompt = { [Symbol.asyncIterator]: () => ({ next: () => done.then(() => ({ done: true, value: undefined })) }) };
+    const session = query({
+        prompt,
+        options: {
+            cwd,
+            settingSources: ["project"],
+            tools: [],
+            settings: { autoMemoryEnabled: false, disableClaudeAiConnectors: false },
+            ...(options.pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable: options.pathToClaudeCodeExecutable } : {}),
+            ...(options.env ? { env: options.env } : {}),
+        },
+    });
+    void (async () => {
+        for await (const message of session)
+            void message;
+    })().catch(() => undefined);
+    try {
+        const connectors = async () => (await session.mcpServerStatus()).filter((server) => server.scope === "claudeai" || server.name.startsWith(CONNECTOR_PREFIX));
+        // Connectors come from the account after the session starts: wait until none is pending.
+        const deadline = Date.now() + (options.timeoutMs ?? 10_000);
+        let found = await connectors().catch(() => []);
+        while (Date.now() < deadline && (!found.length || found.some((server) => server.status === "pending"))) {
+            await new Promise((resolve) => setTimeout(resolve, 400));
+            found = await connectors().catch(() => []);
+        }
+        return found.map((server) => server.name);
+    }
+    catch {
+        return [];
+    }
+    finally {
+        release();
+        session.close();
+    }
+}

package/dist/core/hooks/remoteGate.d.ts

@@ -0,0 +1,22 @@
+import type { HookCallback } from "@anthropic-ai/claude-agent-sdk";
+/** What a call to a remote MCP server does (#70): goes on, asks the person first, or is blocked. */
+export type RemoteServersPolicy = "allow" | "ask" | "deny";
+/**
+ * PreToolUse hook for remote MCP servers (#70): what the model sends one leaves the computer.
+ * - A claude.ai connector's tool the agent didn't choose is always blocked: a connector the
+ *   account gained after the session opened, which the session's denylist doesn't name.
+ * - A remote server's tool (an installed extension's, the agent's own, a chosen connector) goes
+ *   on with `allow`; with `ask`, the person approves each call, told where it goes (blocked when
+ *   no one can be asked); with `deny`, it's blocked.
+ * Approving gives no decision of its own, so the other gates (plan mode, the file scope) still judge.
+ */
+export declare function createRemoteGate(options: {
+    runDir: string;
+    policy: RemoteServersPolicy;
+    /** Where a tool's call goes (a host, a connector), or nothing when it isn't remote. */
+    destination: (tool: string) => string | undefined;
+    /** The chosen connectors' tool prefixes (`serverToolPrefix()`). */
+    allowedConnectors: readonly string[];
+    /** Whether a person can be asked now (not autonomous). */
+    canAsk: () => boolean;
+}): HookCallback;

package/dist/core/hooks/remoteGate.js

@@ -0,0 +1,35 @@
+import { askForDecision } from "./humanInput.js";
+import { isConnectorTool } from "../claudeAiConnectors.js";
+import { t } from "../messages/index.js";
+/**
+ * PreToolUse hook for remote MCP servers (#70): what the model sends one leaves the computer.
+ * - A claude.ai connector's tool the agent didn't choose is always blocked: a connector the
+ *   account gained after the session opened, which the session's denylist doesn't name.
+ * - A remote server's tool (an installed extension's, the agent's own, a chosen connector) goes
+ *   on with `allow`; with `ask`, the person approves each call, told where it goes (blocked when
+ *   no one can be asked); with `deny`, it's blocked.
+ * Approving gives no decision of its own, so the other gates (plan mode, the file scope) still judge.
+ */
+export function createRemoteGate(options) {
+    const deny = (input, reason) => ({ hookSpecificOutput: { hookEventName: input.hook_event_name, permissionDecision: "deny", permissionDecisionReason: reason } });
+    return async (input) => {
+        const pre = input;
+        const tool = pre.tool_name;
+        if (isConnectorTool(tool) && !options.allowedConnectors.some((prefix) => tool.startsWith(prefix))) {
+            return deny(pre, "This agent doesn't use that claude.ai connector: it isn't one of the connectors it lets in. Don't call it again.");
+        }
+        const destination = options.destination(tool);
+        if (!destination || options.policy === "allow")
+            return {};
+        if (options.policy === "deny" || !options.canAsk()) {
+            return deny(pre, `This agent sends nothing to remote servers here: calling ${destination} isn't allowed. Do the task without it, or tell the person it needs that service.`);
+        }
+        const answer = await askForDecision(options.runDir, {
+            title: t().remoteCallTitle(destination),
+            lines: [t().toolLine(tool), t().parametersLine(JSON.stringify(pre.tool_input, null, 2))],
+        });
+        if (answer === "" || answer === "y" || answer === "yes")
+            return {};
+        return deny(pre, `The person didn't let this call go to ${destination}.`);
+    };
+}

package/dist/core/messages/de.js

@@ -60,6 +60,9 @@ export const de = {
     extensionAlreadySignedIn: (name) => `(${name} ist bereits angemeldet)`,
     extensionSignInUnavailable: (name) => `(bei ${name} kann man sich hier nicht anmelden: sie läuft nicht in dieser Sitzung, hat keinen entfernten Server, oder das SDK dieses Agenten kann es nicht)`,
     extensionSignedOut: (name) => `(bei ${name} abgemeldet: sie bittet dich, dich erneut anzumelden)`,
+    remoteCallTitle: (destination) => `Das an ${destination} senden? Es verlässt diesen Computer`,
+    connectorsAllowed: (names) => `claude.ai-Connectoren: ${names}`,
+    connectorsMissing: (names) => `Nicht in deinem claude.ai-Konto: ${names} (verbinde ihn auf claude.ai und öffne die Sitzung neu)`,
     extensionInstalled: (name) => `(${name} installiert: in einem neuen Gespräch da, oder sofort mit /extensions reload, ohne dieses zu verlieren)`,
     extensionUpdated: (name, from, to) => `(${name} aktualisiert, ${from} → ${to}: in einem neuen Gespräch da, oder sofort mit /extensions reload)`,
     extensionsUpToDate: "(alle Erweiterungen aus einem Marketplace sind aktuell)",

package/dist/core/messages/en.d.ts

@@ -82,6 +82,12 @@ export interface Messages {
     extensionAlreadySignedIn(name: string): string;
     extensionSignInUnavailable(name: string): string;
     extensionSignedOut(name: string): string;
+    /** Before a call to a remote MCP server, when the agent asks first (#70): where it goes. */
+    remoteCallTitle(destination: string): string;
+    /** In /extensions: the claude.ai connectors let in (#70). */
+    connectorsAllowed(names: string): string;
+    /** In /extensions: connectors the agent asked for that the account hasn't. */
+    connectorsMissing(names: string): string;
     extensionUpdated(name: string, from: string, to: string): string;
     extensionsUpToDate: string;
     extensionRemoved(name: string, withData: boolean): string;

package/dist/core/messages/en.js

@@ -60,6 +60,9 @@ export const en = {
     extensionAlreadySignedIn: (name) => `(${name} is already signed in)`,
     extensionSignInUnavailable: (name) => `(${name} can't be signed in to here: it isn't running in this session, has no remote server, or this agent's SDK can't sign in)`,
     extensionSignedOut: (name) => `(signed out of ${name}: it will ask you to sign in again)`,
+    remoteCallTitle: (destination) => `Send this to ${destination}? It leaves this computer`,
+    connectorsAllowed: (names) => `claude.ai connectors: ${names}`,
+    connectorsMissing: (names) => `Not in your claude.ai account: ${names} (connect it on claude.ai, then reopen the session)`,
     extensionUpdated: (name, from, to) => `(${name} updated, ${from} → ${to}: it's there in a new conversation, or now with /extensions reload)`,
     extensionsUpToDate: "(every extension from a marketplace is up to date)",
     extensionRemoved: (name, withData) => `(${name} removed${withData ? ", with its data" : "; its data is kept for a reinstall"})`,

package/dist/core/messages/es.js

@@ -60,6 +60,9 @@ export const es = {
     extensionAlreadySignedIn: (name) => `(${name} ya tiene la sesión iniciada)`,
     extensionSignInUnavailable: (name) => `(no se puede iniciar sesión en ${name} aquí: no se ejecuta en esta sesión, no tiene servidor remoto, o el SDK de este agente no sabe hacerlo)`,
     extensionSignedOut: (name) => `(sesión cerrada en ${name}: te pedirá que vuelvas a iniciarla)`,
+    remoteCallTitle: (destination) => `¿Enviar esto a ${destination}? Sale de este ordenador`,
+    connectorsAllowed: (names) => `Conectores de claude.ai: ${names}`,
+    connectorsMissing: (names) => `No están en tu cuenta de claude.ai: ${names} (conéctalo en claude.ai y vuelve a abrir la sesión)`,
     extensionInstalled: (name) => `(${name} instalada: está en una conversación nueva, o ya con /extensions reload, sin perder esta)`,
     extensionUpdated: (name, from, to) => `(${name} actualizada, ${from} → ${to}: está en una conversación nueva, o ya con /extensions reload)`,
     extensionsUpToDate: "(todas las extensiones de un marketplace están al día)",

package/dist/core/messages/fr.js

@@ -60,6 +60,9 @@ export const fr = {
     extensionAlreadySignedIn: (name) => `(${name} est déjà connectée)`,
     extensionSignInUnavailable: (name) => `(impossible de se connecter à ${name} ici : elle ne tourne pas dans cette session, n'a pas de serveur distant, ou le SDK de cet agent ne sait pas le faire)`,
     extensionSignedOut: (name) => `(déconnecté de ${name} : elle vous demandera de vous reconnecter)`,
+    remoteCallTitle: (destination) => `Envoyer ceci à ${destination} ? Cela quitte cet ordinateur`,
+    connectorsAllowed: (names) => `Connecteurs claude.ai : ${names}`,
+    connectorsMissing: (names) => `Absents de votre compte claude.ai : ${names} (connectez-le sur claude.ai, puis rouvrez la session)`,
     extensionInstalled: (name) => `(${name} installée : elle est là dans une nouvelle conversation, ou dès maintenant avec /extensions reload, en gardant celle-ci)`,
     extensionUpdated: (name, from, to) => `(${name} mise à jour, ${from} → ${to} : elle est là dans une nouvelle conversation, ou dès maintenant avec /extensions reload)`,
     extensionsUpToDate: "(toutes les extensions d'un marketplace sont à jour)",

package/dist/core/runner.js

@@ -35,6 +35,29 @@ function signInControls(result) {
         ...(clear ? { mcpClearAuth: (server) => clear(server) } : {}),
     };
 }
+/**
+ * Turns back on the servers the CLI saved as switched off in an earlier session (#75):
+ * `toggleMcpServer(name, false)` is saved in the Claude Code config of the session's folder
+ * (`~/.claude.json`, `disabledMcpServers`), not only in the session (confirmed empirically, CLI
+ * 2.1.300), so a server the kit passes again would start disabled. The kit passes only what it
+ * wants running, so one of them that starts disabled is turned on, which also removes the saved
+ * entry. Only while the session's servers start: switching one off later in the session is the
+ * live switch's (liveExtensions.ts).
+ */
+async function restoreSavedSwitches(result, options) {
+    const passed = new Set(Object.keys(options.mcpServers ?? {}));
+    if (!passed.size)
+        return;
+    for (let attempt = 0; attempt < 30; attempt++) {
+        const status = (await result.mcpServerStatus().catch(() => [])).filter((server) => passed.has(server.name));
+        for (const server of status)
+            if (server.status === "disabled")
+                await result.toggleMcpServer(server.name, true).catch(() => undefined);
+        if (status.length && !status.some((server) => server.status === "pending" || server.status === "disabled"))
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+}
 /**
  * Thin wrapper around the SDK's own `query()`: same two-argument shape (a plain string
  * for a one-shot run, or an `AsyncIterable<SDKUserMessage>` — see `createInputQueue()` —
@@ -56,6 +79,7 @@ export function runQuery(prompt, options) {
         mcpServerStatus: () => result.mcpServerStatus(),
         ...signInControls(result),
     });
+    void restoreSavedSwitches(result, options);
     // The main agent's tool calls by id, to name the results that come back for them.
     const toolNames = new Map();
     async function* generateEvents() {

package/dist/core/session.d.ts

@@ -77,6 +77,11 @@ export interface ExtensionsStatus {
     sessionTools?: () => readonly string[];
     /** Its MCP servers as they are now (empty until it has started): which remote ones need signing in (#61). */
     serverStatus?: () => Promise<McpServerStatus[]>;
+    /** The claude.ai connectors let in (#70), and the ones asked for that the account hasn't; none when the agent asks for none. */
+    connectors?: {
+        allowed: string[];
+        missing: string[];
+    };
 }
 /**
  * The CLI's folder for a project, where it keeps each session's transcript and large tool

package/dist/core/session.js

@@ -8,6 +8,8 @@ import { createSubagentTypeGate } from "./hooks/subagentTypeGate.js";
 import { createSubagentForegroundGate } from "./hooks/subagentForegroundGate.js";
 import { createFileScopeGate } from "./hooks/fileScopeGate.js";
 import { createPlanGate } from "./hooks/planGate.js";
+import { createRemoteGate } from "./hooks/remoteGate.js";
+import { chooseConnectors, discoverConnectors, serverToolPrefix } from "./claudeAiConnectors.js";
 import { createHumanApprovalServer } from "./tools/humanApproval.js";
 import { createManualLoginServer } from "./tools/manualLogin.js";
 import { createTimeServer } from "./tools/time.js";
@@ -200,6 +202,12 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
     ];
     // Packaged, the SDK would look for its CLI binary inside the archive, and hang (#42).
     const claudeExecutable = unpackedClaudeExecutable();
+    // The claude.ai connectors the agent lets in (#70): the account asked which it has, the rest
+    // denied by name (a session setting, never the person's config). None asked, none looked for.
+    const connectors = config.claudeAiConnectors?.length
+        ? chooseConnectors(await discoverConnectors(config.projectDir, claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {}), config.claudeAiConnectors)
+        : undefined;
+    const allowedConnectors = connectors?.allowed ?? [];
     const sdkOptions = {
         ...(claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {}),
         systemPrompt: withReplyLine(promptSections.join("\n\n")),
@@ -220,7 +228,8 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
             autoCompactEnabled: options.autoCompactEnabled ?? true,
             autoMemoryEnabled: false,
             includeGitInstructions: false,
-            disableClaudeAiConnectors: true,
+            disableClaudeAiConnectors: !allowedConnectors.length,
+            ...(allowedConnectors.length && connectors.denied.length ? { deniedMcpServers: connectors.denied.map((serverName) => ({ serverName })) } : {}),
             // An installed extension's plugin may carry hooks: none run (ADR-025). The kit's own,
             // passed in `hooks`, still do (confirmed empirically).
             ...(externalPlugins.size ? { disableAllHooks: true } : {}),
@@ -292,6 +301,18 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
         hooks: {
             PreToolUse: [
                 { hooks: [transcriptLogger.preToolUse] },
+                // Remote servers (#70): connectors not chosen are blocked; the rest as `remoteServers` says.
+                {
+                    hooks: [
+                        createRemoteGate({
+                            runDir,
+                            policy: config.remoteServers ?? "allow",
+                            destination: (tool) => remoteDestinations.find(([prefix]) => tool.startsWith(prefix))?.[1],
+                            allowedConnectors: allowedConnectors.map(serverToolPrefix),
+                            canAsk: () => modeControl.mode !== "autonomous",
+                        }),
+                    ],
+                },
                 ...(fileTools.length || toolOnlyDirs.length
                     ? [{ hooks: [createFileScopeGate({
                                     projectDir: config.projectDir,
@@ -342,6 +363,24 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
             PostToolUse: [{ hooks: [transcriptLogger.postToolUse] }],
         },
     };
+    // Where each remote server's calls go (#70), for the remote gate: an http/sse server's host
+    // (an installed extension's, the agent's own), or the claude.ai connector itself.
+    const remoteDestinations = [
+        ...Object.entries(sdkOptions.mcpServers ?? {}).flatMap(([name, server]) => {
+            const remote = server;
+            if ((remote.type !== "http" && remote.type !== "sse") || !remote.url)
+                return [];
+            let host = remote.url;
+            try {
+                host = new URL(remote.url).host;
+            }
+            catch {
+                // Not a URL the kit can read: the address as given.
+            }
+            return [[serverToolPrefix(name), host]];
+        }),
+        ...allowedConnectors.map((name) => [serverToolPrefix(name), name]),
+    ];
     // The extensions' own hooks (the memory hears the person's messages), after the kit's.
     for (const contribution of added) {
         for (const [event, matchers] of Object.entries(contribution.hooks ?? {})) {
@@ -360,6 +399,7 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
         sessionTools: () => late.view?.controls().tools ?? [],
         serverStatus: async () => (await late.view?.controls().mcpServerStatus?.().catch(() => [])) ?? [],
         inactive: resolved.inactive,
+        ...(connectors ? { connectors: { allowed: connectors.allowed, missing: connectors.missing } } : {}),
     };
     // What the session is, for the extensions that ask (sessionFacts.ts, #43).
     const viewBase = {
@@ -378,6 +418,7 @@ export async function buildSessionOptions(config, runDir, spec, options = {}) {
             })),
             // Its own list: /extensions' status has another, and the live switch changes both.
             inactive: [...resolved.inactive],
+            ...(connectors ? { connectors: { allowed: connectors.allowed, missing: connectors.missing } } : {}),
         },
         subagents: Object.entries(allAgents).map(([name, agent]) => ({ name, description: agent.description })),
         skills: sdkOptions.skills === "all" ? await pluginSkills(pluginRoots) : [...(sdkOptions.skills ?? [])],

package/dist/core/sessionFacts.d.ts

@@ -37,6 +37,11 @@ export interface SessionFacts {
             name: string;
             reason: string;
         }[];
+        /** The claude.ai connectors let in (#70), and the ones asked for that the account hasn't. */
+        connectors?: {
+            allowed: string[];
+            missing: string[];
+        };
     };
     /** The subagents it can delegate to. */
     subagents: {
@@ -93,6 +98,7 @@ export type StaticSessionFacts = Omit<SessionFacts, "mode" | "switchableModes" |
             servers: string[];
         })[];
         inactive: SessionFacts["extensions"]["inactive"];
+        connectors?: SessionFacts["extensions"]["connectors"];
     };
 };
 export interface SessionView {

package/dist/core/sessionFacts.js

@@ -26,6 +26,7 @@ export function createSessionView(base, modeControl) {
                         tools: tools.length ? tools.filter((tool) => servers.some((server) => tool.startsWith(`mcp__${server}__`))) : servers.map((server) => `mcp__${server}__*`),
                     })),
                     inactive: base.extensions.inactive,
+                    ...(base.extensions.connectors ? { connectors: base.extensions.connectors } : {}),
                 },
                 tools,
                 skills: live.skills ?? base.skills,

package/dist/extensions/awareness/tools.js

@@ -27,6 +27,12 @@ export function describeSession(facts) {
     });
     const inactive = facts.extensions.inactive.map(({ name, reason }) => `- **${name}** is off: it ${reason}.`);
     sections.push(`## Extensions\n\n${[...active, ...inactive].join("\n") || "None."}`);
+    // The claude.ai connectors let in (#70): the account's integrations, not installed extensions.
+    const connectors = facts.extensions.connectors;
+    if (connectors && (connectors.allowed.length || connectors.missing.length)) {
+        const missing = connectors.missing.length ? ` Asked for but not in the person's claude.ai account: ${connectors.missing.join(", ")} (they connect it on claude.ai, then the session opens again).` : "";
+        sections.push(`## claude.ai connectors\n\n${connectors.allowed.length ? `${connectors.allowed.join(", ")}: their tools are the person's claude.ai integrations; what you send them leaves the computer.` : "None of the ones asked for."}${missing}`);
+    }
     if (facts.subagents.length)
         sections.push(`## Subagents you can delegate to\n\n${facts.subagents.map(({ name, description }) => `- **${name}**: ${description}`).join("\n")}`);
     const own = facts.tools.filter((tool) => !tool.startsWith("mcp__"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@falkenslab/agent-kit",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "Library for building an agent on top of the Claude Agent SDK",
   "author": "Francisco Vargas Ruiz",
   "license": "MIT",