@frockbot/plugin-mcp 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-mcp",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "private": false,
   "type": "module",
   "exports": {
@@ -25,13 +25,13 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/configuration-core": "0.1.2",
-    "@frockbot/connection-core": "0.1.2",
-    "@frockbot/kernel-contracts": "0.1.2",
-    "@frockbot/plugin-credentials": "0.1.2",
-    "@frockbot/plugin-settings": "0.1.2",
-    "@frockbot/plugin-tools": "0.1.2",
-    "@frockbot/plugin-web": "0.1.2",
+    "@frockbot/configuration-core": "0.1.4",
+    "@frockbot/connection-core": "0.1.4",
+    "@frockbot/kernel-contracts": "0.1.4",
+    "@frockbot/plugin-credentials": "0.1.4",
+    "@frockbot/plugin-settings": "0.1.4",
+    "@frockbot/plugin-tools": "0.1.4",
+    "@frockbot/plugin-web": "0.1.4",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {

package/src/agent.test.ts

@@ -6,7 +6,7 @@ import {
   createConfiguredMcpRuntimeContribution,
   decodeMcpConnectionSettingsV1,
   MAX_MCP_SERVERS_PER_USER_V1,
-  mcpAssignmentResolutionV1,
+  mcpCapabilityResolutionV1,
   mcpConnectionLifecycleV1,
   mcpServerSlugV1,
   mcpToolNameV1,
@@ -96,20 +96,19 @@ function server(options: {
 async function mount(config: {
   fetch: typeof fetch;
   connection?: ConnectionView;
-  assignmentIndex?: number;
+  capabilityIndex?: number;
   failures?: string[];
   outcomes?: unknown[];
 }): Promise<{ root: Context; mounted: boolean }> {
   const plugin = await createConfiguredMcpRuntimeContribution({
-    assignment: {
+    capability: {
       packageId: "mcp",
       capabilityId: "mcp-tools",
       connectionId: "mcp-1",
-      state: "enabled",
     },
-    ...(config.assignmentIndex === undefined
+    ...(config.capabilityIndex === undefined
       ? {}
-      : { assignmentIndex: config.assignmentIndex }),
+      : { capabilityIndex: config.capabilityIndex }),
     userId: "user-1",
     readSecret: () => undefined,
     authorizeConnection: () =>
@@ -170,7 +169,7 @@ describe("Connection-scoped settings", () => {
   });
 });
 
-describe("mounting one Assignment", () => {
+describe("mounting one enabled Capability", () => {
   test("registers every listed tool with the server's own schema", async () => {
     const { root } = await mount({ fetch: server({}) });
 
@@ -284,7 +283,7 @@ describe("mounting one Assignment", () => {
     const { mounted } = await mount({
       failures,
       fetch: server({}),
-      assignmentIndex: MAX_MCP_SERVERS_PER_USER_V1,
+      capabilityIndex: MAX_MCP_SERVERS_PER_USER_V1,
     });
 
     expect(mounted).toBe(false);
@@ -385,13 +384,13 @@ describe("the durable lifecycle a mount participates in", () => {
     });
   });
 
-  test("the Assignment's resolution key moves with the server epoch", () => {
-    const before = mcpAssignmentResolutionV1({
-      assignment: { connectionId: "mcp-1" },
+  test("the Capability's resolution key moves with the server epoch", () => {
+    const before = mcpCapabilityResolutionV1({
+      capability: { connectionId: "mcp-1" },
       connection: connection({ safeMetadata: { serverEpoch: 1 } }),
     });
-    const restarted = mcpAssignmentResolutionV1({
-      assignment: { connectionId: "mcp-1" },
+    const restarted = mcpCapabilityResolutionV1({
+      capability: { connectionId: "mcp-1" },
       connection: connection({ safeMetadata: { serverEpoch: 2 } }),
     });
     expect(restarted).not.toBe(before);

package/src/agent.ts

@@ -1,5 +1,5 @@
 /**
- * The runtime Contribution: one enabled Assignment of `mcp-tools` becomes one
+ * The runtime Contribution: one enabled `mcp-tools` Capability becomes one
  * remote MCP server's tools in the Bot's tool registry.
  *
  * Everything the Bot ever sees of a server passes through here, and every byte
@@ -27,7 +27,7 @@ import {
 import { mcpAuthorizationRequiredV1 } from "./oauth.js";
 import { decodeOutboundMcpUrlV1 } from "./ssrf.js";
 import {
-  mcpAssignmentResolutionKeyV1,
+  mcpCapabilityResolutionKeyV1,
   mcpFailureCodeV1,
   MAX_MCP_INSTRUCTIONS_BYTES_V1,
   type McpFailureCodeV1,
@@ -62,8 +62,8 @@ export const MCP_TOOL_SUBAGENT_ROLES: readonly string[] = ["executor"];
 
 /**
  * The durable per-User ceiling on remote MCP servers. Counted over the enabled
- * Assignments of this Package, so a Bot cannot be handed a seventeenth server
- * by adding one more Assignment.
+ * Capabilities of this Package, so a Bot cannot be handed a seventeenth server
+ * by enabling one more Connection.
  */
 export const MAX_MCP_SERVERS_PER_USER_V1 = 16;
 
@@ -200,18 +200,17 @@ function isObject(value: unknown): value is Record<string, unknown> {
 }
 
 export interface McpRuntimeContributionConfig {
-  assignment: {
+  capability: {
     packageId: string;
     capabilityId: string;
     connectionId?: string;
-    state: string;
   };
   /**
-   * This Assignment's ordinal among the enabled Assignments of this Package,
+   * This Capability's ordinal among the enabled ones of this Package,
    * which is what makes the per-User server ceiling countable from inside a
-   * per-Assignment factory.
+   * per-Capability factory.
    */
-  assignmentIndex?: number;
+  capabilityIndex?: number;
   userId: string;
   readSecret(name: string): string | undefined;
   authorizeConnection(): Promise<ConnectionView>;
@@ -240,7 +239,7 @@ export interface McpRuntimeContributionConfig {
 }
 
 /**
- * Resolve one Assignment into a mounted runtime Plugin. The handshake and
+ * Resolve one enabled Capability into a mounted runtime Plugin. The handshake and
  * `tools/list` happen here, before the Plugin mounts, so a server that cannot
  * be reached contributes nothing instead of half-registering.
  */
@@ -248,23 +247,22 @@ export async function createConfiguredMcpRuntimeContribution(
   config: McpRuntimeContributionConfig,
 ): Promise<Plugin.Function | undefined> {
   if (
-    config.assignment.packageId !== MCP_PACKAGE_ID ||
-    config.assignment.capabilityId !== MCP_CAPABILITY_ID ||
-    config.assignment.state !== "enabled" ||
-    !config.assignment.connectionId
+    config.capability.packageId !== MCP_PACKAGE_ID ||
+    config.capability.capabilityId !== MCP_CAPABILITY_ID ||
+    !config.capability.connectionId
   ) {
     return undefined;
   }
-  if ((config.assignmentIndex ?? 0) >= MAX_MCP_SERVERS_PER_USER_V1) {
+  if ((config.capabilityIndex ?? 0) >= MAX_MCP_SERVERS_PER_USER_V1) {
     config.onFailure?.(
-      `A User may assign at most ${MAX_MCP_SERVERS_PER_USER_V1} MCP servers`,
+      `A User may enable at most ${MAX_MCP_SERVERS_PER_USER_V1} MCP servers`,
     );
     return undefined;
   }
   const fetchImpl = config.fetch ?? boundFetch;
   let client: McpClient | undefined;
   let lifecycle: { serverEpoch?: number; instructions?: string } = {};
-  const connectionId = config.assignment.connectionId;
+  const connectionId = config.capability.connectionId;
   try {
     const connection = await config.authorizeConnection();
     lifecycle = mcpConnectionLifecycleV1(connection);
@@ -275,7 +273,7 @@ export async function createConfiguredMcpRuntimeContribution(
     const apiKey =
       connection.connectionTypeId === MCP_KEYED_CONNECTION_TYPE_ID ||
       connection.connectionTypeId === MCP_OAUTH_CONNECTION_TYPE_ID
-        ? await openAssignedCredential(config, connection)
+        ? await openEnabledCredential(config, connection)
         : undefined;
     client = new McpClient({
       url: settings.url,
@@ -372,18 +370,18 @@ export async function createConfiguredMcpRuntimeContribution(
 }
 
 /**
- * What one Assignment of `mcp-tools` resolves to, including the server's
+ * What one enabled `mcp-tools` Capability resolves to, including the server's
  * `serverEpoch`. A restart bumps the epoch, so this key changes, so the next
  * admitted Turn resolves a different mount and re-handshakes — while the
  * in-flight Turn, holding the client it already mounted, is untouched.
  */
-export function mcpAssignmentResolutionV1(config: {
-  assignment: { connectionId?: string };
+export function mcpCapabilityResolutionV1(config: {
+  capability: { connectionId?: string };
   connection: { generation?: string; safeMetadata?: Record<string, unknown> };
 }): string {
   const lifecycle = mcpConnectionLifecycleV1(config.connection);
-  return mcpAssignmentResolutionKeyV1({
-    connectionId: config.assignment.connectionId ?? "",
+  return mcpCapabilityResolutionKeyV1({
+    connectionId: config.capability.connectionId ?? "",
     ...(config.connection.generation === undefined
       ? {}
       : { connectionGeneration: config.connection.generation }),
@@ -393,7 +391,7 @@ export function mcpAssignmentResolutionV1(config: {
   });
 }
 
-async function openAssignedCredential(
+async function openEnabledCredential(
   config: McpRuntimeContributionConfig,
   connection: ConnectionView,
 ): Promise<string> {

package/src/lifecycle-tools.ts

@@ -12,7 +12,7 @@
  *
  * These tools need no Connection: they read and write the User's own MCP
  * records through the host the Bot's Durable Object supplies, which is why
- * this Contribution mounts for a Turn rather than for an Assignment.
+ * this Contribution mounts for a Turn rather than for one Capability.
  */
 import type {
   Session,

package/src/records.test.ts

@@ -7,7 +7,7 @@ import {
   decodeMcpRefusalRecordV1,
   decodeMcpServerRecordV1,
   decodeMcpServerStatusViewV1,
-  mcpAssignmentResolutionKeyV1,
+  mcpCapabilityResolutionKeyV1,
   mcpConnectionMetadataV1,
   mcpFailureCodeV1,
   type McpServerRecordV1,
@@ -263,19 +263,19 @@ describe("the mount outcome that crosses back from a Bot", () => {
   });
 });
 
-describe("the Assignment resolution key", () => {
+describe("the Capability resolution key", () => {
   test("changes when the server epoch changes, and only then", () => {
-    const before = mcpAssignmentResolutionKeyV1({
+    const before = mcpCapabilityResolutionKeyV1({
       connectionId: "mcp-1",
       connectionGeneration: "gen-1",
       serverEpoch: 1,
     });
-    const restarted = mcpAssignmentResolutionKeyV1({
+    const restarted = mcpCapabilityResolutionKeyV1({
       connectionId: "mcp-1",
       connectionGeneration: "gen-1",
       serverEpoch: 2,
     });
-    const again = mcpAssignmentResolutionKeyV1({
+    const again = mcpCapabilityResolutionKeyV1({
       connectionId: "mcp-1",
       connectionGeneration: "gen-1",
       serverEpoch: 1,
@@ -286,13 +286,13 @@ describe("the Assignment resolution key", () => {
 
   test("changes when the Connection generation changes", () => {
     expect(
-      mcpAssignmentResolutionKeyV1({
+      mcpCapabilityResolutionKeyV1({
         connectionId: "mcp-1",
         connectionGeneration: "gen-2",
         serverEpoch: 1,
       }),
     ).not.toBe(
-      mcpAssignmentResolutionKeyV1({
+      mcpCapabilityResolutionKeyV1({
         connectionId: "mcp-1",
         connectionGeneration: "gen-1",
         serverEpoch: 1,

package/src/records.ts

@@ -96,7 +96,7 @@ export interface McpServerRecordV1 {
   transport: "streamable-http" | "sse";
   instructions?: string;
   /**
-   * Bumped by `mcp/restart`. It participates in the Assignment's resolution
+   * Bumped by `mcp/restart`. It participates in the Capability's resolution
    * key, so the next admitted Turn resolves a different mount and
    * re-handshakes; the in-flight Turn keeps the client it already has.
    */
@@ -653,12 +653,12 @@ export function decodeMcpMountOutcomeV1(
 }
 
 /**
- * What one Assignment of `mcp-tools` resolves to. The `serverEpoch` is in it,
+ * What one enabled `mcp-tools` Capability resolves to. The `serverEpoch` is in it,
  * which is the whole of restart semantics: a restart changes this key, the
  * next admitted Turn resolves a different mount and re-handshakes, and the
  * in-flight Turn — already holding its client — is untouched.
  */
-export function mcpAssignmentResolutionKeyV1(input: {
+export function mcpCapabilityResolutionKeyV1(input: {
   connectionId: string;
   connectionGeneration?: string;
   serverEpoch?: number;

package/src/user.ts

@@ -531,7 +531,7 @@ export class McpUserBackendContribution {
         if (connection.state === "revoked" || connection.state === "revoking") {
           throw new Error("MCP Connection is revoked");
         }
-        // The epoch bump is the whole of restart: it is in the Assignment's
+        // The epoch bump is the whole of restart: it is in the Capability's
         // resolution key, so the next admitted Turn resolves a different
         // mount and re-handshakes, while the in-flight Turn keeps the client
         // it already holds. The handshake here refreshes the status the User
@@ -704,7 +704,7 @@ export class McpUserBackendContribution {
       // The Connection generation and the credential generation are the same
       // thing for a keyed server, and deliberately are not for an OAuth one: a
       // refresh rotates the sealed generation without disturbing the
-      // Assignment resolution key a Turn is pinned to.
+      // Capability resolution key a Turn is pinned to.
       expectedGeneration: await this.currentCredentialGeneration(
         input.accountId,
         connection,
@@ -1518,8 +1518,8 @@ export class McpUserBackendContribution {
           { ...connection, state, failure: undefined },
         );
         // GrokBot's `RemoveMcpAccount`: the server is gone, so its record is
-        // gone with it. The Assignments that named it become unavailable
-        // tombstones through the ordinary Connection dependency path.
+        // gone with it. Any Bot that was using the Connection fails closed
+        // when its next Turn resolves the User's enabled capability set.
         await this.removeServer(connection.connectionId);
         return this.receipt(command.commandId, connection.connectionId);
       }