@frockbot/plugin-composio 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-composio",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "private": false,
   "type": "module",
   "exports": {
@@ -22,11 +22,11 @@
     "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-settings": "0.1.2",
-    "@frockbot/plugin-tools": "0.1.2",
+    "@frockbot/configuration-core": "0.1.4",
+    "@frockbot/connection-core": "0.1.4",
+    "@frockbot/kernel-contracts": "0.1.4",
+    "@frockbot/plugin-settings": "0.1.4",
+    "@frockbot/plugin-tools": "0.1.4",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {

package/src/agent.ts

@@ -32,26 +32,24 @@ export interface ComposioRouterPluginConfig {
 }
 
 export function createConfiguredComposioRuntimeContribution(config: {
-  assignment: {
+  capability: {
     packageId: string;
     capabilityId: string;
     connectionId?: string;
-    state: string;
   };
   userId: string;
   readSecret(name: string): string | undefined;
   authorizeConnection(): Promise<{ safeMetadata: Record<string, unknown> }>;
 }): Plugin.Function | undefined {
   if (
-    config.assignment.packageId !== "composio" ||
-    config.assignment.capabilityId !== "gmail-tools" ||
-    config.assignment.state !== "enabled" ||
-    !config.assignment.connectionId
+    config.capability.packageId !== "composio" ||
+    config.capability.capabilityId !== "gmail-tools" ||
+    !config.capability.connectionId
   ) {
     return undefined;
   }
   const apiKey = config.readSecret("COMPOSIO_API_KEY");
-  if (!apiKey) throw new Error("Assigned Composio Connection is misconfigured");
+  if (!apiKey) throw new Error("Enabled Composio Connection is misconfigured");
   const authorizeEffect = async () => {
     const connection = await config.authorizeConnection();
     const connectedAccountId = connection.safeMetadata.connectedAccountId;

package/src/backend.test.ts

@@ -15,7 +15,6 @@ describe("configured Composio backend", () => {
     callbackBaseUrl: "https://bot.frockbot.com",
     readSecret: (name: string) => secrets[name],
     storeFor: () => ({}) as ComposioConnectionStore,
-    markConnectionUnavailable: () => Promise.resolve("applied" as const),
   });
 
   test("requires a strong dedicated authorization-state secret without auth fallback", () => {

package/src/backend.ts

@@ -76,24 +76,12 @@ export interface ComposioBackendConfig {
   connectionTypes: Record<string, ComposioConnectionTypeConfig>;
   authorizationStateSecret: string;
   storeFor(userId: string): ComposioConnectionStore;
-  markBotUnavailable?: (
-    userId: string,
-    botId: string,
-    connectionId: string,
-    compensation: { id: string; expectedGeneration: string },
-  ) => Promise<"applied" | "stale">;
 }
 
 export interface ComposioBackendHost {
   callbackBaseUrl: string;
   readSecret(name: string): string | undefined;
   storeFor(userId: string): ComposioConnectionStore;
-  markConnectionUnavailable(
-    userId: string,
-    botId: string,
-    connectionId: string,
-    compensation: { id: string; expectedGeneration: string },
-  ): Promise<"applied" | "stale">;
 }
 
 export function createConfiguredComposioBackendContribution(
@@ -126,7 +114,6 @@ export function createConfiguredComposioBackendContribution(
         toolkitSlug: "gmail",
       },
     },
-    markBotUnavailable: host.markConnectionUnavailable,
   });
 }
 
@@ -161,7 +148,6 @@ function coordinator(
     store: config.storeFor(userId),
     callbackBaseUrl: config.callbackBaseUrl,
     connectionTypes: config.connectionTypes,
-    markBotUnavailable: config.markBotUnavailable,
   });
 }
 

package/src/connections.ts

@@ -11,7 +11,6 @@ import type {
   RevokeConnectionResult,
   StartConnectionResult,
 } from "./backend-contracts.js";
-import { isSettledBotCompensation } from "./connection-recovery.js";
 import {
   linkReconciliationDisposition,
   reconcileComposioProviderConnection,
@@ -61,11 +60,6 @@ export interface ComposioConnectionStore {
       authorizationStateId?: string;
     },
   ): Promise<boolean>;
-  recordAssignmentCompensated(
-    userId: string,
-    connectionId: string,
-    compensationId: string,
-  ): Promise<boolean>;
   requireConnectionReconciliation(
     userId: string,
     connectionId: string,
@@ -101,12 +95,6 @@ export interface ComposioConnectionCoordinatorConfig {
   store: ComposioConnectionStore;
   callbackBaseUrl: string;
   connectionTypes: Record<string, ComposioConnectionTypeConfig>;
-  markBotUnavailable?: (
-    userId: string,
-    botId: string,
-    connectionId: string,
-    compensation: { id: string; expectedGeneration: string },
-  ) => Promise<"applied" | "stale">;
 }
 
 export class DefinitiveConnectionOperationError extends Error {
@@ -720,46 +708,6 @@ export class ComposioConnectionCoordinator {
     if (refreshed?.safeMetadata.revocationProviderCompleted !== true) {
       return { schemaVersion: 1, status: "reconciliation-required" };
     }
-    const compensations = Array.isArray(
-      refreshed.safeMetadata.assignmentCompensations,
-    )
-      ? refreshed.safeMetadata.assignmentCompensations
-      : [];
-    if (this.config.markBotUnavailable) {
-      for (const candidate of compensations) {
-        if (
-          !candidate ||
-          typeof candidate !== "object" ||
-          Array.isArray(candidate)
-        ) {
-          return { schemaVersion: 1, status: "reconciliation-required" };
-        }
-        const compensation = candidate as Record<string, unknown>;
-        if (
-          typeof compensation.botId !== "string" ||
-          typeof compensation.id !== "string" ||
-          typeof compensation.expectedGeneration !== "string"
-        ) {
-          return { schemaVersion: 1, status: "reconciliation-required" };
-        }
-        const result = await this.config.markBotUnavailable(
-          userId,
-          compensation.botId,
-          connectionId,
-          {
-            id: compensation.id,
-            expectedGeneration: compensation.expectedGeneration,
-          },
-        );
-        if (isSettledBotCompensation(result)) {
-          await this.config.store.recordAssignmentCompensated(
-            userId,
-            connectionId,
-            compensation.id,
-          );
-        }
-      }
-    }
     const finished = await this.config.store.finishConnectionRevocation(
       userId,
       connectionId,

package/src/index.ts

@@ -1,7 +1,5 @@
 export * from "./agent.js";
 export * from "./backend.js";
 export * from "./composio-client.js";
-export * from "./connection-recovery.js";
 export * from "./connections.js";
-export * from "./dependency-coordination.js";
 export * from "./provider-reconciliation.js";

package/src/user-configuration.test.ts

@@ -1,14 +1,10 @@
 import { describe, expect, test } from "bun:test";
 import {
   USER_PROFILE_PLACEHOLDER_NAME_V1,
-  type ConnectionView,
   type UserConfigurationCommandV1,
   type UserSettingsViewV1,
 } from "@frockbot/configuration-core";
-import {
-  createComposioUserBackendContribution,
-  deriveRevocationCompensations,
-} from "./user-configuration.js";
+import { createComposioUserBackendContribution } from "./user-configuration.js";
 import { ComposioClient } from "./composio-client.js";
 import { ComposioConnectionCoordinator } from "./connections.js";
 import { reconcileComposioProviderConnection } from "./provider-reconciliation.js";
@@ -67,7 +63,6 @@ function backendHost(
 ) {
   return {
     state: { storage } as unknown as DurableObjectState,
-    env: {} as never,
     availablePackages: [{ packageId: "composio", version: "0.0.1" }],
     reconcileProviderConnection,
     revokeConnectedAccount,
@@ -94,19 +89,6 @@ function deferred<T>() {
   return { promise, resolve };
 }
 
-function connection(
-  safeMetadata: ConnectionView["safeMetadata"],
-): ConnectionView {
-  return {
-    connectionId: "connection-1",
-    packageId: "composio",
-    connectionTypeId: "gmail",
-    displayName: "Gmail",
-    state: "ready",
-    safeMetadata,
-  };
-}
-
 async function startInstalledConnection(
   contribution: ReturnType<typeof createComposioUserBackendContribution>,
   input: Parameters<
@@ -131,126 +113,7 @@ async function startInstalledConnection(
   return contribution.startConnection("user-1", input);
 }
 
-describe("Connection revocation dependencies", () => {
-  test("uses only acknowledged explicit Assignments", async () => {
-    expect(
-      await deriveRevocationCompensations(
-        connection({
-          targetBotId: "oauth-initiator",
-          dependentAssignments: [
-            { botId: "pending", generation: "gen-pending", status: "pending" },
-            {
-              botId: "acknowledged",
-              generation: "gen-acknowledged",
-              status: "acknowledged",
-            },
-          ],
-        }),
-      ),
-    ).toEqual([
-      {
-        botId: "acknowledged",
-        id: expect.stringMatching(/^revocation-[a-f0-9]{64}$/),
-        expectedGeneration: "gen-acknowledged",
-      },
-    ]);
-  });
-
-  test("keeps compensation identifiers unique and within the RPC bound", async () => {
-    const generation = "g".repeat(128);
-    const [first, second] = await deriveRevocationCompensations(
-      connection({
-        dependentAssignments: [
-          { botId: "primary", generation, status: "acknowledged" },
-          { botId: "secondary", generation, status: "acknowledged" },
-        ],
-      }),
-    );
-
-    expect(first).toMatchObject({ expectedGeneration: generation });
-    expect(second).toMatchObject({ expectedGeneration: generation });
-    expect(first?.id).not.toBe(second?.id);
-    expect(first?.id.length).toBeLessThanOrEqual(128);
-    expect(second?.id.length).toBeLessThanOrEqual(128);
-  });
-
-  test("ignores legacy Bot metadata even when it has a generation", async () => {
-    expect(
-      await deriveRevocationCompensations(
-        connection({
-          targetBotId: "legacy-bot",
-          assignmentGeneration: "gen-legacy",
-        }),
-      ),
-    ).toEqual([]);
-  });
-
-  test("retries durable Bot compensation through the versioned RPC envelope", async () => {
-    const storage = new MemoryStorage();
-    const requests: unknown[] = [];
-    await storage.put({
-      "user-id": "user-1",
-      "user-configuration": {
-        schemaVersion: 1,
-        revision: 1,
-        profile: { name: "User" },
-        packages: [],
-        connections: [
-          {
-            ...connection({
-              connectedAccountId: "account-1",
-              revocationProviderCompleted: true,
-              assignmentCompensationPending: true,
-              assignmentCompensations: [
-                {
-                  botId: "primary",
-                  id: "compensation-1",
-                  expectedGeneration: "generation-1",
-                },
-              ],
-              compensationRetryAt: 0,
-            }),
-            state: "revoking",
-          },
-        ],
-      } satisfies UserSettingsViewV1,
-    });
-    const contribution = createComposioUserBackendContribution({
-      ...backendHost(storage),
-      env: {
-        BOT_STATES: {
-          idFromName: (name: string) => name,
-          get: () => ({
-            markConnectionUnavailable: (request: unknown) => {
-              requests.push(request);
-              return Promise.resolve("applied" as const);
-            },
-          }),
-        },
-      } as never,
-    });
-
-    await contribution.alarm();
-
-    expect(requests).toEqual([
-      {
-        schemaVersion: 1,
-        userId: "user-1",
-        botId: "primary",
-        connectionId: "connection-1",
-        compensation: {
-          id: "compensation-1",
-          expectedGeneration: "generation-1",
-        },
-      },
-    ]);
-    expect(
-      await contribution.getConnection("user-1", "connection-1"),
-    ).toMatchObject({ state: "revoked" });
-  });
-});
-
-describe("Connection dependency admission", () => {
+describe("Connection admission", () => {
   test("replays a Package receipt before deployment availability changes", async () => {
     const storage = new MemoryStorage();
     const host = backendHost(storage);
@@ -438,7 +301,7 @@ describe("Connection dependency admission", () => {
     expect((await upgraded.read("user-1")).connections).toEqual([]);
   });
 
-  test("atomically enforces the Package and Connection Type requirement", async () => {
+  test("decodes the seam and admits an enabled Package's Connection", async () => {
     const storage = new MemoryStorage();
     const contribution = createComposioUserBackendContribution({
       ...backendHost(storage),
@@ -498,55 +361,52 @@ describe("Connection dependency admission", () => {
       state: "ready",
     });
 
-    const requirement = {
-      schemaVersion: 1 as const,
-      packageId: "composio",
-      packageVersion: "0.0.1",
-      capabilityId: "gmail-tools",
-      connectionTypeIds: ["gmail"],
-    };
-    expect(
-      await contribution.claimConnectionDependency(
-        "user-1",
-        "gmail-1",
-        "primary",
-        "generation-1",
-        { ...requirement, packageVersion: "9.9.9" },
-      ),
-    ).toBe(false);
-    expect(
-      await contribution.claimConnectionDependency(
-        "user-1",
-        "gmail-1",
-        "primary",
-        "generation-1",
-        { ...requirement, connectionTypeIds: ["calendar"] },
-      ),
-    ).toBe(false);
-    const beforeClaim = await read();
-    expect(beforeClaim.revision).toBe(3);
-    expect(beforeClaim.connections[0]?.safeMetadata).not.toHaveProperty(
-      "dependentAssignments",
-    );
+    expect(await read()).toMatchObject({
+      revision: 3,
+      connections: [{ connectionId: "gmail-1", state: "ready" }],
+    });
+  });
+});
 
-    expect(
-      await contribution.claimConnectionDependency(
-        "user-1",
-        "gmail-1",
-        "primary",
-        "generation-1",
-        requirement,
-      ),
-    ).toBe(true);
-    expect((await read()).connections[0]?.safeMetadata).toMatchObject({
-      dependentAssignments: [
-        {
-          botId: "primary",
-          generation: "generation-1",
-          status: "pending",
+describe("Connection revocation", () => {
+  test("disconnects without dependent bookkeeping and replays idempotently", async () => {
+    const storage = new MemoryStorage();
+    const contribution = createComposioUserBackendContribution(
+      backendHost(storage),
+    );
+    await startInstalledConnection(contribution, {
+      connectionId: "gmail-1",
+      packageId: "composio",
+      connectionTypeId: "gmail",
+      displayName: "Gmail",
+    });
+    await contribution.finishConnectionAuthorization("user-1", "gmail-1", {
+      state: "ready",
+      safeMetadata: { connectedAccountId: "account-1" },
+    });
+    let providerRevocations = 0;
+    const coordinator = new ComposioConnectionCoordinator({
+      client: new ComposioClient({
+        apiKey: "secret",
+        fetch: (_input, init) => {
+          expect(init?.method).toBe("POST");
+          providerRevocations += 1;
+          return Promise.resolve(Response.json({ success: true }));
         },
-      ],
+      }),
+      store: contribution,
+      callbackBaseUrl: "https://app.example.com",
+      connectionTypes: {},
     });
+
+    const first = await coordinator.revoke("user-1", "gmail-1");
+    const replay = await coordinator.revoke("user-1", "gmail-1");
+
+    expect(first).toEqual({ schemaVersion: 1, status: "revoked" });
+    expect(replay).toEqual(first);
+    expect(providerRevocations).toBe(1);
+    const connection = await contribution.getConnection("user-1", "gmail-1");
+    expect(connection?.state).toBe("revoked");
   });
 });
 

package/src/user-configuration.ts

@@ -1,7 +1,5 @@
 import {
-  decodeConnectionDependencyRequirementV1,
   USER_PROFILE_PLACEHOLDER_NAME_V1,
-  type ConnectionDependencyRequirementV1,
   type UserSettingsViewV1,
 } from "@frockbot/configuration-core";
 import {
@@ -11,15 +9,6 @@ import {
   // pi-lens-ignore: ts:2307
 } from "@frockbot/plugin-settings/user";
 import type { Plugin } from "cordis";
-import {
-  acknowledgeDependentAssignment,
-  claimDependentAssignment,
-  compensateDependentAssignment,
-} from "./dependency-coordination.js";
-import {
-  completeAssignmentCompensation,
-  isSettledBotCompensation,
-} from "./connection-recovery.js";
 import {
   linkReconciliationDisposition,
   type ComposioProviderReconciliationRequest,
@@ -61,68 +50,8 @@ function readyAuthorizationMetadata(
   };
 }
 
-async function revocationCompensationId(
-  botId: string,
-  generation: string,
-): Promise<string> {
-  const digest = await crypto.subtle.digest(
-    "SHA-256",
-    new TextEncoder().encode(`${botId}\u0000${generation}`),
-  );
-  return `revocation-${Array.from(new Uint8Array(digest), (byte) =>
-    byte.toString(16).padStart(2, "0"),
-  ).join("")}`;
-}
-
-export async function deriveRevocationCompensations(
-  connection: UserSettingsViewV1["connections"][number],
-): Promise<Array<{ botId: string; id: string; expectedGeneration: string }>> {
-  const dependencies = Array.isArray(
-    connection.safeMetadata.dependentAssignments,
-  )
-    ? connection.safeMetadata.dependentAssignments
-    : [];
-  const dependenciesByKey = new Map<string, string>();
-  for (const candidate of dependencies) {
-    if (
-      !candidate ||
-      typeof candidate !== "object" ||
-      Array.isArray(candidate)
-    ) {
-      continue;
-    }
-    const dependency = candidate as Record<string, unknown>;
-    if (
-      typeof dependency.botId === "string" &&
-      typeof dependency.generation === "string" &&
-      dependency.status === "acknowledged"
-    ) {
-      dependenciesByKey.set(
-        `${dependency.botId}\u0000${dependency.generation}`,
-        dependency.generation,
-      );
-    }
-  }
-  return Promise.all(
-    [...dependenciesByKey].map(async ([key, expectedGeneration]) => {
-      const botId = key.slice(0, key.indexOf("\u0000"));
-      return {
-        botId,
-        id: await revocationCompensationId(botId, expectedGeneration),
-        expectedGeneration,
-      };
-    }),
-  );
-}
-
-export interface UserConfigurationEnv {
-  BOT_STATES: DurableObjectNamespace;
-  COMPOSIO_API_KEY?: string;
-}
-
 export interface ComposioUserBackendHost {
   state: DurableObjectState;
-  env: UserConfigurationEnv;
   availablePackages: readonly { packageId: string; version: string }[];
   reconcileProviderConnection(
     request: ComposioProviderReconciliationRequest,
@@ -170,12 +99,6 @@ function nextConnectionAlarm(settings: UserSettingsViewV1): number | undefined {
     ) {
       values.push(metadata.reconciliationRetryAt);
     }
-    if (
-      metadata.assignmentCompensationPending === true &&
-      typeof metadata.compensationRetryAt === "number"
-    ) {
-      values.push(metadata.compensationRetryAt);
-    }
     return values;
   });
   return deadlines.length > 0 ? Math.min(...deadlines) : undefined;
@@ -243,7 +166,6 @@ const initialState = (): UserSettingsViewV1 => ({
 
 export class ComposioUserBackendContribution {
   readonly ctx: DurableObjectState;
-  readonly env: UserConfigurationEnv;
   private readonly settings: UserSettingsBackendContribution;
   private readonly availablePackages: ReadonlySet<string>;
   private readonly reconcileProviderConnection: ComposioUserBackendHost["reconcileProviderConnection"];
@@ -251,7 +173,6 @@ export class ComposioUserBackendContribution {
 
   constructor(host: ComposioUserBackendHost) {
     this.ctx = host.state;
-    this.env = host.env;
     this.settings = createUserSettingsBackendContribution({
       storage: host.state.storage,
       availablePackages: host.availablePackages,
@@ -482,8 +403,6 @@ export class ComposioUserBackendContribution {
         throw new Error("Pending Link cannot enter cleanup");
       }
       const effectDeadlineAt = Date.now() + CONNECTION_EFFECT_ALARM_MS;
-      const assignmentCompensations =
-        await deriveRevocationCompensations(connection);
       const claimed = {
         ...connection,
         state: "revoking" as const,
@@ -496,11 +415,6 @@ export class ComposioUserBackendContribution {
           reconciliationOperation: "revoke",
           revocationProviderCompleted: false,
           effectDeadlineAt,
-          assignmentCompensationPending: assignmentCompensations.length > 0,
-          assignmentCompensations,
-          ...(assignmentCompensations.length > 0
-            ? { compensationRetryAt: effectDeadlineAt }
-            : {}),
         },
         failure: "Lost Connect Link cleanup requires provider reconciliation",
       };
@@ -631,92 +545,6 @@ export class ComposioUserBackendContribution {
     });
   }
 
-  async recordAssignmentCompensated(
-    userId: string,
-    connectionId: string,
-    compensationId: string,
-  ): Promise<boolean> {
-    return this.transitionConnection(userId, connectionId, (connection) =>
-      completeAssignmentCompensation(connection, compensationId),
-    );
-  }
-
-  async claimConnectionDependency(
-    userId: string,
-    connectionId: string,
-    botId: string,
-    generation: string,
-    requirement: ConnectionDependencyRequirementV1,
-  ): Promise<boolean> {
-    const decoded = decodeConnectionDependencyRequirementV1(requirement);
-    await this.assertIdentity(userId);
-    return this.ctx.storage.transaction(async (transaction) => {
-      const current =
-        (await transaction.get<UserSettingsViewV1>(STATE_KEY)) ??
-        initialState();
-      const installation = current.packages.find(
-        (pkg) =>
-          pkg.packageId === decoded.packageId &&
-          pkg.version === decoded.packageVersion &&
-          pkg.state === "installed",
-      );
-      const connection = current.connections.find(
-        (item) => item.connectionId === connectionId,
-      );
-      if (
-        !installation ||
-        !connection ||
-        connection.packageId !== decoded.packageId ||
-        !decoded.connectionTypeIds.includes(connection.connectionTypeId)
-      ) {
-        return false;
-      }
-      const nextConnection = claimDependentAssignment(
-        connection,
-        botId,
-        generation,
-      );
-      if (!nextConnection) return false;
-      const next = {
-        ...current,
-        revision: current.revision + 1,
-        connections: current.connections.map((item) =>
-          item.connectionId === connectionId ? nextConnection : item,
-        ),
-      } satisfies UserSettingsViewV1;
-      await transaction.put(STATE_KEY, next);
-      const alarmAt = nextConnectionAlarm(next);
-      if (alarmAt === undefined) {
-        await transaction.deleteAlarm();
-      } else {
-        await transaction.setAlarm(Math.max(Date.now(), alarmAt));
-      }
-      return true;
-    });
-  }
-
-  async acknowledgeConnectionDependency(
-    userId: string,
-    connectionId: string,
-    botId: string,
-    generation: string,
-  ): Promise<boolean> {
-    return this.transitionConnection(userId, connectionId, (connection) =>
-      acknowledgeDependentAssignment(connection, botId, generation),
-    );
-  }
-
-  async compensateConnectionDependency(
-    userId: string,
-    connectionId: string,
-    botId: string,
-    generation: string,
-  ): Promise<boolean> {
-    return this.transitionConnection(userId, connectionId, (connection) =>
-      compensateDependentAssignment(connection, botId, generation),
-    );
-  }
-
   async requireConnectionReconciliation(
     userId: string,
     connectionId: string,
@@ -848,8 +676,6 @@ export class ComposioUserBackendContribution {
         return { phase: "pending" as const, connection: pending };
       }
       const effectDeadlineAt = Date.now() + CONNECTION_EFFECT_ALARM_MS;
-      const assignmentCompensations =
-        await deriveRevocationCompensations(connection);
       const claimed = {
         ...connection,
         state: "revoking" as const,
@@ -858,11 +684,6 @@ export class ComposioUserBackendContribution {
           reconciliationOperation: "revoke",
           revocationProviderCompleted: false,
           effectDeadlineAt,
-          assignmentCompensationPending: assignmentCompensations.length > 0,
-          assignmentCompensations,
-          ...(assignmentCompensations.length > 0
-            ? { compensationRetryAt: effectDeadlineAt }
-            : {}),
         },
         failure: undefined,
       };
@@ -915,8 +736,6 @@ export class ComposioUserBackendContribution {
     return this.transitionConnection(userId, connectionId, (connection) => {
       if (
         connection.safeMetadata.revocationProviderCompleted !== true ||
-        (Array.isArray(connection.safeMetadata.assignmentCompensations) &&
-          connection.safeMetadata.assignmentCompensations.length > 0) ||
         (connection.state !== "revoking" &&
           !(
             connection.state === "reconciliation-required" &&
@@ -938,12 +757,6 @@ export class ComposioUserBackendContribution {
         initialState();
       const now = Date.now();
       let changed = false;
-      const pending: Array<{
-        connectionId: string;
-        botId: string;
-        compensationId: string;
-        expectedGeneration: string;
-      }> = [];
       const reconciliations: Array<{
         connection: UserSettingsViewV1["connections"][number];
         operation: "link" | "revoke";
@@ -1032,49 +845,6 @@ export class ComposioUserBackendContribution {
           changed = true;
         }
 
-        if (
-          next.safeMetadata.assignmentCompensationPending === true &&
-          typeof next.safeMetadata.compensationRetryAt === "number" &&
-          next.safeMetadata.compensationRetryAt <= now
-        ) {
-          const stored = Array.isArray(
-            next.safeMetadata.assignmentCompensations,
-          )
-            ? next.safeMetadata.assignmentCompensations
-            : [];
-          for (const candidate of stored) {
-            if (
-              !candidate ||
-              typeof candidate !== "object" ||
-              Array.isArray(candidate)
-            ) {
-              continue;
-            }
-            const compensation = candidate as Record<string, unknown>;
-            if (
-              typeof compensation.botId === "string" &&
-              typeof compensation.id === "string" &&
-              typeof compensation.expectedGeneration === "string"
-            ) {
-              pending.push({
-                connectionId: next.connectionId,
-                botId: compensation.botId,
-                compensationId: compensation.id,
-                expectedGeneration: compensation.expectedGeneration,
-              });
-            }
-          }
-          if (stored.length > 0) {
-            next = {
-              ...next,
-              safeMetadata: {
-                ...next.safeMetadata,
-                compensationRetryAt: now + CONNECTION_EFFECT_ALARM_MS,
-              },
-            };
-            changed = true;
-          }
-        }
         return next;
       });
       const next = {
@@ -1089,10 +859,10 @@ export class ComposioUserBackendContribution {
       } else {
         await transaction.setAlarm(Math.max(Date.now(), alarmAt));
       }
-      return { compensations: pending, reconciliations };
+      return reconciliations;
     });
 
-    for (const reconciliation of pending.reconciliations) {
+    for (const reconciliation of pending) {
       try {
         const connection = reconciliation.connection;
         if (reconciliation.operation === "link") {
@@ -1260,49 +1030,6 @@ export class ComposioUserBackendContribution {
         // Durable reconciliation state and its alarm deadline remain stored.
       }
     }
-
-    for (const compensation of pending.compensations) {
-      try {
-        const id = this.env.BOT_STATES.idFromName(
-          `${userId}:${compensation.botId}`,
-        );
-        // SAFETY: BOT_STATES binds BotState, whose public RPC method below is
-        // stable; workers-types cannot infer the generated Durable Object stub.
-        const bot = this.env.BOT_STATES.get(id) as unknown as {
-          markConnectionUnavailable(request: {
-            schemaVersion: 1;
-            userId: string;
-            botId: string;
-            connectionId: string;
-            compensation: { id: string; expectedGeneration: string };
-          }): Promise<"applied" | "stale">;
-        };
-        const result = await bot.markConnectionUnavailable({
-          schemaVersion: 1,
-          userId,
-          botId: compensation.botId,
-          connectionId: compensation.connectionId,
-          compensation: {
-            id: compensation.compensationId,
-            expectedGeneration: compensation.expectedGeneration,
-          },
-        });
-        if (!isSettledBotCompensation(result)) continue;
-        const cleared = await this.recordAssignmentCompensated(
-          userId,
-          compensation.connectionId,
-          compensation.compensationId,
-        );
-        if (cleared) {
-          await this.finishConnectionRevocation(
-            userId,
-            compensation.connectionId,
-          );
-        }
-      } catch {
-        // Durable compensation intent and its retry deadline remain stored.
-      }
-    }
   }
 
   private async transitionConnection(

package/src/connection-recovery.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ConnectionView } from "@frockbot/configuration-core";
-import {
-  completeAssignmentCompensation,
-  isSettledBotCompensation,
-} from "./connection-recovery.js";
-
-function connection(
-  state: ConnectionView["state"],
-  safeMetadata: ConnectionView["safeMetadata"],
-): ConnectionView {
-  return {
-    connectionId: "connection-1",
-    packageId: "composio",
-    connectionTypeId: "gmail",
-    displayName: "Gmail",
-    state,
-    safeMetadata,
-  };
-}
-
-describe("Connection recovery", () => {
-  test("treats stale Bot generations as settled compensation", () => {
-    expect(isSettledBotCompensation("stale")).toBe(true);
-    expect(isSettledBotCompensation("applied")).toBe(true);
-  });
-
-  test("keeps revocation scheduled until every generation settles", () => {
-    const revoking = connection("revoking", {
-      assignmentCompensationPending: true,
-      compensationRetryAt: Date.now() + 60_000,
-      assignmentCompensations: [
-        { botId: "primary", id: "old", expectedGeneration: "gen-old" },
-        { botId: "primary", id: "new", expectedGeneration: "gen-new" },
-      ],
-    });
-
-    const afterOld = completeAssignmentCompensation(revoking, "old");
-    const afterNew = afterOld
-      ? completeAssignmentCompensation(afterOld, "new")
-      : undefined;
-
-    expect(afterOld?.safeMetadata).toMatchObject({
-      assignmentCompensationPending: true,
-      assignmentCompensations: [
-        { botId: "primary", id: "new", expectedGeneration: "gen-new" },
-      ],
-    });
-    expect(afterNew?.safeMetadata.assignmentCompensations).toEqual([]);
-    expect(afterNew?.safeMetadata).not.toHaveProperty(
-      "assignmentCompensationPending",
-    );
-  });
-});

package/src/connection-recovery.ts

@@ -1,52 +0,0 @@
-import type { ConnectionView } from "@frockbot/configuration-core";
-
-export type BotCompensationResult = "applied" | "stale";
-
-export function isSettledBotCompensation(
-  result: BotCompensationResult,
-): boolean {
-  return result === "applied" || result === "stale";
-}
-
-export function completeAssignmentCompensation(
-  connection: ConnectionView,
-  compensationId: string,
-): ConnectionView | undefined {
-  if (Array.isArray(connection.safeMetadata.assignmentCompensations)) {
-    const remaining = connection.safeMetadata.assignmentCompensations.filter(
-      (candidate) =>
-        !candidate ||
-        typeof candidate !== "object" ||
-        Array.isArray(candidate) ||
-        (candidate as Record<string, unknown>).id !== compensationId,
-    );
-    if (
-      remaining.length ===
-      connection.safeMetadata.assignmentCompensations.length
-    ) {
-      return undefined;
-    }
-    const {
-      compensationRetryAt,
-      assignmentCompensationPending: _,
-      ...safeMetadata
-    } = connection.safeMetadata;
-    return {
-      ...connection,
-      safeMetadata: {
-        ...safeMetadata,
-        assignmentCompensations: remaining,
-        ...(remaining.length > 0
-          ? {
-              assignmentCompensationPending: true,
-              compensationRetryAt:
-                typeof compensationRetryAt === "number"
-                  ? compensationRetryAt
-                  : Date.now() + 60_000,
-            }
-          : {}),
-      },
-    };
-  }
-  return undefined;
-}

package/src/dependency-coordination.test.ts

@@ -1,136 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ConnectionView } from "@frockbot/configuration-core";
-import {
-  acknowledgeDependentAssignment,
-  claimDependentAssignment,
-  compensateDependentAssignment,
-  releaseDependentAssignment,
-} from "./dependency-coordination.js";
-
-function assignmentConnection(): ConnectionView {
-  return {
-    connectionId: "connection-1",
-    packageId: "composio",
-    connectionTypeId: "gmail",
-    displayName: "Gmail",
-    state: "ready",
-    safeMetadata: {},
-  };
-}
-
-describe("Connection dependency coordination", () => {
-  test("records intent before acknowledgement and rejects revocation races", () => {
-    const claimed = claimDependentAssignment(
-      assignmentConnection(),
-      "bot-1",
-      "generation-1",
-    );
-    expect(claimed?.safeMetadata.dependentAssignments).toEqual([
-      { botId: "bot-1", generation: "generation-1", status: "pending" },
-    ]);
-    expect(
-      acknowledgeDependentAssignment(claimed!, "bot-1", "generation-1")
-        ?.safeMetadata.dependentAssignments,
-    ).toEqual([
-      {
-        botId: "bot-1",
-        generation: "generation-1",
-        status: "acknowledged",
-      },
-    ]);
-    expect(
-      claimDependentAssignment(
-        {
-          ...assignmentConnection(),
-          state: "revoking",
-          safeMetadata: {
-            ...assignmentConnection().safeMetadata,
-            revocationRequested: true,
-          },
-        },
-        "bot-1",
-        "generation-1",
-      ),
-    ).toBeUndefined();
-  });
-
-  test("keeps two same-Bot Assignment generations independent on one Connection", () => {
-    const acknowledged = {
-      ...assignmentConnection(),
-      state: "ready" as const,
-      safeMetadata: {
-        dependentAssignments: [
-          {
-            botId: "bot-1",
-            generation: "generation-1",
-            status: "acknowledged",
-          },
-        ],
-      },
-    };
-    const claimed = claimDependentAssignment(
-      acknowledged,
-      "bot-1",
-      "generation-2",
-    );
-
-    expect(claimed?.safeMetadata.dependentAssignments).toEqual([
-      {
-        botId: "bot-1",
-        generation: "generation-1",
-        status: "acknowledged",
-      },
-      { botId: "bot-1", generation: "generation-2", status: "pending" },
-    ]);
-    expect(
-      compensateDependentAssignment(claimed!, "bot-1", "generation-2")
-        ?.safeMetadata.dependentAssignments,
-    ).toEqual([
-      {
-        botId: "bot-1",
-        generation: "generation-1",
-        status: "acknowledged",
-      },
-    ]);
-    const bothAcknowledged = acknowledgeDependentAssignment(
-      claimed!,
-      "bot-1",
-      "generation-2",
-    );
-    expect(bothAcknowledged?.safeMetadata.dependentAssignments).toEqual([
-      {
-        botId: "bot-1",
-        generation: "generation-1",
-        status: "acknowledged",
-      },
-      {
-        botId: "bot-1",
-        generation: "generation-2",
-        status: "acknowledged",
-      },
-    ]);
-
-    const firstReleased = releaseDependentAssignment(
-      bothAcknowledged!,
-      "bot-1",
-      "generation-1",
-    );
-    expect(firstReleased?.safeMetadata.dependentAssignments).toEqual([
-      {
-        botId: "bot-1",
-        generation: "generation-2",
-        status: "acknowledged",
-      },
-    ]);
-    expect(
-      releaseDependentAssignment(bothAcknowledged!, "bot-1", "generation-2")
-        ?.safeMetadata.dependentAssignments,
-    ).toEqual([
-      {
-        botId: "bot-1",
-        generation: "generation-1",
-        status: "acknowledged",
-      },
-    ]);
-  });
-});

package/src/dependency-coordination.ts

@@ -1,140 +0,0 @@
-import type { ConnectionView } from "@frockbot/configuration-core";
-
-export function claimDependentAssignment(
-  connection: ConnectionView,
-  botId: string,
-  generation: string,
-): ConnectionView | undefined {
-  if (
-    connection.state === "revoking" ||
-    connection.state === "revoked" ||
-    connection.state === "failed" ||
-    connection.safeMetadata.revocationRequested === true
-  ) {
-    return undefined;
-  }
-  if (connection.state !== "ready") {
-    return undefined;
-  }
-  const existing = Array.isArray(connection.safeMetadata.dependentAssignments)
-    ? connection.safeMetadata.dependentAssignments.filter(
-        (candidate) =>
-          candidate &&
-          typeof candidate === "object" &&
-          !Array.isArray(candidate) &&
-          typeof (candidate as Record<string, unknown>).botId === "string",
-      )
-    : [];
-  return {
-    ...connection,
-    safeMetadata: {
-      ...connection.safeMetadata,
-      dependentAssignments: [
-        ...existing.filter(
-          (candidate) =>
-            (candidate as Record<string, unknown>).botId !== botId ||
-            (candidate as Record<string, unknown>).generation !== generation,
-        ),
-        { botId, generation, status: "pending" },
-      ],
-    },
-  };
-}
-
-export function acknowledgeDependentAssignment(
-  connection: ConnectionView,
-  botId: string,
-  generation: string,
-): ConnectionView | undefined {
-  if (
-    connection.state === "revoking" ||
-    connection.state === "revoked" ||
-    connection.safeMetadata.revocationRequested === true
-  ) {
-    return undefined;
-  }
-  const dependencies = Array.isArray(
-    connection.safeMetadata.dependentAssignments,
-  )
-    ? connection.safeMetadata.dependentAssignments
-    : [];
-  let matched = false;
-  const acknowledged = dependencies.map((candidate) => {
-    if (
-      candidate &&
-      typeof candidate === "object" &&
-      !Array.isArray(candidate) &&
-      (candidate as Record<string, unknown>).botId === botId &&
-      (candidate as Record<string, unknown>).generation === generation
-    ) {
-      matched = true;
-      return { ...candidate, status: "acknowledged" };
-    }
-    return candidate;
-  });
-  if (!matched) return undefined;
-  return {
-    ...connection,
-    safeMetadata: {
-      ...connection.safeMetadata,
-      dependentAssignments: acknowledged,
-    },
-  };
-}
-
-export function releaseDependentAssignment(
-  connection: ConnectionView,
-  botId: string,
-  generation: string,
-): ConnectionView | undefined {
-  const dependencies = Array.isArray(
-    connection.safeMetadata.dependentAssignments,
-  )
-    ? connection.safeMetadata.dependentAssignments
-    : [];
-  const remaining = dependencies.filter(
-    (candidate) =>
-      !candidate ||
-      typeof candidate !== "object" ||
-      Array.isArray(candidate) ||
-      (candidate as Record<string, unknown>).botId !== botId ||
-      (candidate as Record<string, unknown>).generation !== generation,
-  );
-  if (remaining.length === dependencies.length) return undefined;
-  return {
-    ...connection,
-    safeMetadata: {
-      ...connection.safeMetadata,
-      dependentAssignments: remaining,
-    },
-  };
-}
-
-export function compensateDependentAssignment(
-  connection: ConnectionView,
-  botId: string,
-  generation: string,
-): ConnectionView | undefined {
-  const dependencies = Array.isArray(
-    connection.safeMetadata.dependentAssignments,
-  )
-    ? connection.safeMetadata.dependentAssignments
-    : [];
-  const remaining = dependencies.filter(
-    (candidate) =>
-      !candidate ||
-      typeof candidate !== "object" ||
-      Array.isArray(candidate) ||
-      (candidate as Record<string, unknown>).botId !== botId ||
-      (candidate as Record<string, unknown>).generation !== generation ||
-      (candidate as Record<string, unknown>).status !== "pending",
-  );
-  if (remaining.length === dependencies.length) return undefined;
-  return {
-    ...connection,
-    safeMetadata: {
-      ...connection.safeMetadata,
-      dependentAssignments: remaining,
-    },
-  };
-}