@frockbot/plugin-shell 0.1.2 → 0.1.4

package/src/backend-execution.ts

@@ -6,7 +6,6 @@ import type {
 import type {
   BotExecutionPlanV1,
   BotSettingsViewV1,
-  ConnectionView,
 } from "@frockbot/configuration-core";
 import type { BotTurnCommand, BotTurnCompletion } from "./backend-contracts.js";
 
@@ -17,9 +16,6 @@ export interface BotResidentProjection {
   settings: BotSettingsViewV1;
   executionPlan: BotExecutionPlanV1;
   systemPromptSection: string;
-  authorizeConnection(
-    assignment: BotSettingsViewV1["assignments"][number],
-  ): Promise<ConnectionView>;
 }
 
 export interface BotResidentTurnExecution {

package/src/backend-image.test.ts

@@ -5,8 +5,8 @@ import {
 } from "@frockbot/plugin-image/testing";
 import {
   createBotImageHost,
-  createWorkersAiImageModelV1,
-  decodeWorkersAiImageV1,
+  createNativeAiImageModelV1,
+  decodeNativeAiImageV1,
 } from "./backend-image.ts";
 
 const IDENTITY = { userId: "user-1", botId: "bot-1" };
@@ -56,7 +56,7 @@ describe("normalizing what Workers AI answered", () => {
   const png = fakePngBytesV1(64, 32);
 
   test("accepts the base64 envelope the FLUX models answer", async () => {
-    const buffer = await decodeWorkersAiImageV1({ image: base64(png) });
+    const buffer = await decodeNativeAiImageV1({ image: base64(png) });
     expect([...new Uint8Array(buffer)]).toEqual([...png]);
   });
 
@@ -68,23 +68,23 @@ describe("normalizing what Workers AI answered", () => {
         controller.close();
       },
     });
-    expect([...new Uint8Array(await decodeWorkersAiImageV1(stream))]).toEqual([
+    expect([...new Uint8Array(await decodeNativeAiImageV1(stream))]).toEqual([
       ...png,
     ]);
   });
 
   test("accepts a raw buffer or view", async () => {
     expect([
-      ...new Uint8Array(await decodeWorkersAiImageV1(png.slice().buffer)),
+      ...new Uint8Array(await decodeNativeAiImageV1(png.slice().buffer)),
     ]).toEqual([...png]);
-    expect([...new Uint8Array(await decodeWorkersAiImageV1(png))]).toEqual([
+    expect([...new Uint8Array(await decodeNativeAiImageV1(png))]).toEqual([
       ...png,
     ]);
   });
 
   test("refuses anything else rather than storing it", async () => {
     for (const answer of [undefined, null, 7, "hello", { image: 3 }, {}]) {
-      await expect(decodeWorkersAiImageV1(answer)).rejects.toThrow(
+      await expect(decodeNativeAiImageV1(answer)).rejects.toThrow(
         "not an image",
       );
     }
@@ -92,7 +92,7 @@ describe("normalizing what Workers AI answered", () => {
 
   test("passes the requested size through to the binding", async () => {
     const calls: Array<[string, Record<string, unknown>]> = [];
-    const model = createWorkersAiImageModelV1({
+    const model = createNativeAiImageModelV1({
       run: (name, input) => {
         calls.push([name, input]);
         return Promise.resolve({ image: base64(png) });

package/src/backend-image.ts

@@ -1,15 +1,15 @@
 // The Bot Durable Object's half of the image-generation seam.
 //
 // The Image Package consumes a narrow `ImageModelV1` — one method, answering
-// raw image bytes — and knows nothing about Workers AI. This module is the
+// raw image bytes — and knows nothing about Cloudflare's native AI binding. This module is the
 // adapter: it takes the `AI` binding off the Durable Object's environment,
-// normalizes the three shapes a Workers AI text-to-image model answers in, and
+// normalizes the three shapes a native text-to-image model answers in, and
 // hands the Package a seam with no platform vocabulary in it. "Electron,
 // Cloudflare, provider SDK, and Computer implementation types remain inside
 // their adapters."
 //
 // The binding is optional, exactly as `PACKAGE_BUNDLER` is. A deployment with
-// no Workers AI binding still mounts the Package, and `generate_image` then
+// no native AI binding still mounts the Package, and `generate_image` then
 // refuses visibly on the Turn that calls it — which is a better answer than a
 // tool that silently vanishes from the catalog, and a far better one than a
 // `TypeError` inside the Agent loop.
@@ -38,11 +38,11 @@ export interface BotImageTurn {
 }
 
 /**
- * The Workers AI binding, declared structurally so this module names no
+ * The native AI binding, declared structurally so this module names no
  * Cloudflare type it does not have to. `run` is the whole of what an image
  * model needs from it.
  */
-export interface WorkersAiBindingV1 {
+export interface NativeAiBindingV1 {
   run(model: string, input: Record<string, unknown>): Promise<unknown>;
 }
 
@@ -51,7 +51,7 @@ export interface WorkersAiBindingV1 {
  * as its own type so the binding's absence is a typed state, not a cast.
  */
 export interface BotImageEnv {
-  AI?: WorkersAiBindingV1;
+  AI?: NativeAiBindingV1;
   WORKSPACE_FILES?: WorkspaceFilesV1;
 }
 
@@ -88,7 +88,7 @@ async function readStream(
 }
 
 /**
- * The bytes inside whatever a Workers AI text-to-image model answered.
+ * The bytes inside whatever a native text-to-image model answered.
  *
  * The catalog does not agree with itself: `flux-1-schnell` and the FLUX.2
  * models answer `{ image: "<base64>" }`, the Stable Diffusion models answer a
@@ -96,7 +96,7 @@ async function readStream(
  * directly. Every one of those is an image; none of them is the Package's
  * problem.
  */
-export async function decodeWorkersAiImageV1(
+export async function decodeNativeAiImageV1(
   answer: unknown,
 ): Promise<ArrayBuffer> {
   if (answer instanceof ArrayBuffer) return answer;
@@ -123,15 +123,15 @@ export async function decodeWorkersAiImageV1(
 }
 
 /**
- * The Workers AI binding as an {@link ImageModelV1}.
+ * The native AI binding as an {@link ImageModelV1}.
  *
  * `width` and `height` are passed through: the Stable Diffusion models accept
  * them, and the FLUX models ignore unknown fields rather than refusing. The
  * Package never trusts them to have been honoured — it reads the dimensions
  * back out of the bytes.
  */
-export function createWorkersAiImageModelV1(
-  binding: WorkersAiBindingV1,
+export function createNativeAiImageModelV1(
+  binding: NativeAiBindingV1,
 ): ImageModelV1 {
   return {
     async run(model: string, input: ImageModelInputV1): Promise<ArrayBuffer> {
@@ -140,7 +140,7 @@ export function createWorkersAiImageModelV1(
         width: input.width,
         height: input.height,
       });
-      return await decodeWorkersAiImageV1(answer);
+      return await decodeNativeAiImageV1(answer);
     },
   };
 }
@@ -174,7 +174,7 @@ export function createBotImageHost(
       runId: turn.runId,
     },
     files,
-    ...(bindings.AI ? { model: createWorkersAiImageModelV1(bindings.AI) } : {}),
+    ...(bindings.AI ? { model: createNativeAiImageModelV1(bindings.AI) } : {}),
     ...(modelId ? { modelId } : {}),
   };
 }

package/src/backend-isolate.test.ts

@@ -5,26 +5,24 @@ import type {
 } from "@frockbot/kernel-contracts";
 import {
   createIsolateCapabilityHost,
+  isolateBindingDigestV1,
   isolateModelEventStreamV1,
   ISOLATE_MODEL_FAILURE_MESSAGE,
   ISOLATE_MODEL_REQUEST_PREFIX,
-  matchingModelAssignmentV1,
-  type IsolateAssignmentV1,
+  matchingModelCapabilityV1,
+  type IsolateCapabilityV1,
   type IsolateModelBindingV1,
   type IsolateModelRequestRecordV1,
 } from "./backend-isolate.ts";
 
-const ASSIGNMENT: IsolateAssignmentV1 = {
-  assignmentId: "model-assignment",
+const CAPABILITY: IsolateCapabilityV1 = {
   packageId: "provider-ollama-cloud",
   capabilityId: "ollama-cloud-models",
   kind: "model",
   connectionId: "connection-1",
-  providerModelId: "glm-5.3-flash:cloud",
 };
 
 const BINDING: IsolateModelBindingV1 = {
-  assignmentId: "model-assignment",
   packageId: "provider-ollama-cloud",
   capabilityId: "ollama-cloud-models",
   connectionId: "connection-1",
@@ -69,14 +67,19 @@ function memoryStorage() {
 
 function host(
   options: {
-    binding?: IsolateModelBindingV1;
+    binding?: IsolateModelBindingV1 | null;
+    capabilities?: IsolateCapabilityV1[];
+    unavailableModelBinding?: {
+      provider?: string;
+      providerModelId: string;
+    };
     stream?: (request: NormalizedModelRequest) => AsyncIterable<LlmStreamEvent>;
   } = {},
 ) {
   const storage = memoryStorage();
   const forwarded: NormalizedModelRequest[] = [];
   let minted = 0;
-  const binding = options.binding ?? BINDING;
+  const binding = options.binding === undefined ? BINDING : options.binding;
   return {
     storage,
     forwarded,
@@ -85,55 +88,65 @@ function host(
       botId: "bot-1",
       packageId: "bot-authored",
       generationId: "generation-1",
-      assignments: [ASSIGNMENT],
-      modelBinding: binding,
-      modelPath: {
-        stream: (value) => {
-          forwarded.push(structuredClone(value));
-          return (
-            options.stream?.(value) ??
-            (async function* () {
-              yield { type: "text-delta", text: "hi" } as LlmStreamEvent;
-            })()
-          );
-        },
-      },
+      capabilities: options.capabilities ?? [CAPABILITY],
+      ...(binding
+        ? {
+            modelBinding: binding,
+            modelPath: {
+              stream: (value: NormalizedModelRequest) => {
+                forwarded.push(structuredClone(value));
+                return (
+                  options.stream?.(value) ??
+                  (async function* () {
+                    yield {
+                      type: "text-delta",
+                      text: "hi",
+                    } as LlmStreamEvent;
+                  })()
+                );
+              },
+            },
+          }
+        : {}),
+      ...(options.unavailableModelBinding
+        ? { unavailableModelBinding: options.unavailableModelBinding }
+        : {}),
       newId: () => `minted-${(minted += 1)}`,
       now: () => new Date("2026-08-31T00:00:00.000Z"),
     }),
   };
 }
 
-describe("an isolate model request is bound to its Assignment", () => {
-  test("matches only the exact assigned provider and model", () => {
-    expect(
-      matchingModelAssignmentV1([ASSIGNMENT], BINDING, request()),
-    ).toMatchObject({ assignmentId: "model-assignment" });
+describe("an isolate model request is bound to its enabled Capability", () => {
+  test("matches only the exact authoritative provider and model", () => {
+    expect(matchingModelCapabilityV1([CAPABILITY], BINDING, request())).toEqual(
+      CAPABILITY,
+    );
     expect(
-      matchingModelAssignmentV1(
-        [ASSIGNMENT],
+      matchingModelCapabilityV1(
+        [CAPABILITY],
         BINDING,
         request({ provider: "foundation" }),
       ),
     ).toBeUndefined();
     expect(
-      matchingModelAssignmentV1(
-        [ASSIGNMENT],
+      matchingModelCapabilityV1(
+        [CAPABILITY],
         BINDING,
         request({ model: "some-other-model" }),
       ),
     ).toBeUndefined();
-    // No durable binding at all: an enabled Assignment on its own authorizes
+    // No authoritative binding at all: an enabled Capability on its own authorizes
     // nothing.
     expect(
-      matchingModelAssignmentV1([ASSIGNMENT], undefined, request()),
+      matchingModelCapabilityV1([CAPABILITY], undefined, request()),
     ).toBeUndefined();
   });
 
   test("ignores a Bot-supplied model binding", () => {
     expect(
-      matchingModelAssignmentV1(
-        [ASSIGNMENT],
+      matchingModelCapabilityV1(
+        [CAPABILITY],
         BINDING,
         request({
           provider: "foundation",
@@ -144,7 +157,7 @@ describe("an isolate model request is bound to its Assignment", () => {
     ).toBeUndefined();
   });
 
-  test("a request for an unassigned provider is a pending decision", async () => {
+  test("a request outside the effective binding is a pending decision", async () => {
     const subject = host();
     const outcome = await subject.host.invokeModel(
       request({ provider: "foundation", model: "deterministic-v1" }),
@@ -155,6 +168,53 @@ describe("an isolate model request is bound to its Assignment", () => {
     expect(subject.forwarded).toHaveLength(0);
   });
 
+  test("a request with no durable model binding is a pending decision", async () => {
+    const subject = host({ binding: null, capabilities: [] });
+
+    const outcome = await subject.host.invokeModel(request());
+
+    expect(outcome).toMatchObject({ status: "pending-user-decision" });
+    expect(await subject.host.pendingDecisions()).toHaveLength(1);
+    expect(await subject.host.recordedModelRequests()).toHaveLength(0);
+    expect(subject.forwarded).toHaveLength(0);
+  });
+
+  test("a held model binding with an unavailable Connection is unavailable", async () => {
+    const subject = host({
+      binding: null,
+      capabilities: [],
+      unavailableModelBinding: {
+        provider: BINDING.provider,
+        providerModelId: BINDING.providerModelId,
+      },
+    });
+
+    const outcome = await subject.host.invokeModel(request());
+
+    expect(outcome).toMatchObject({ status: "unavailable" });
+    expect(await subject.host.pendingDecisions()).toHaveLength(0);
+    expect(await subject.host.recordedModelRequests()).toHaveLength(0);
+    expect(subject.forwarded).toHaveLength(0);
+  });
+
+  test("an unavailable binding does not cover another provider", async () => {
+    const subject = host({
+      binding: null,
+      capabilities: [],
+      unavailableModelBinding: {
+        provider: BINDING.provider,
+        providerModelId: BINDING.providerModelId,
+      },
+    });
+
+    const outcome = await subject.host.invokeModel(
+      request({ provider: "foundation" }),
+    );
+
+    expect(outcome).toMatchObject({ status: "pending-user-decision" });
+    expect(await subject.host.pendingDecisions()).toHaveLength(1);
+  });
+
   test("forwards the authority's binding, never the Bot's", async () => {
     const subject = host();
     await subject.host.invokeModel(
@@ -173,6 +233,92 @@ describe("an isolate model request is bound to its Assignment", () => {
   });
 });
 
+describe("User-enabled isolate bindings", () => {
+  test("list projects the complete enabled set", async () => {
+    const subject = host();
+
+    await expect(subject.host.list()).resolves.toEqual([
+      { capabilityId: "ollama-cloud-models", kind: "model" },
+    ]);
+  });
+
+  test("identity, generation, and the enabled set are binding digest inputs", async () => {
+    const first = await isolateBindingDigestV1({
+      userId: "user-1",
+      botId: "bot-1",
+      generationId: "generation-1",
+      capabilities: [CAPABILITY],
+    });
+    const same = await isolateBindingDigestV1({
+      userId: "user-1",
+      botId: "bot-1",
+      generationId: "generation-1",
+      capabilities: [structuredClone(CAPABILITY)],
+    });
+    const otherUser = await isolateBindingDigestV1({
+      userId: "user-2",
+      botId: "bot-1",
+      generationId: "generation-1",
+      capabilities: [CAPABILITY],
+    });
+    const otherBot = await isolateBindingDigestV1({
+      userId: "user-1",
+      botId: "bot-2",
+      generationId: "generation-1",
+      capabilities: [CAPABILITY],
+    });
+    const otherGeneration = await isolateBindingDigestV1({
+      userId: "user-1",
+      botId: "bot-1",
+      generationId: "generation-2",
+      capabilities: [CAPABILITY],
+    });
+    const widened = await isolateBindingDigestV1({
+      userId: "user-1",
+      botId: "bot-1",
+      generationId: "generation-1",
+      capabilities: [
+        CAPABILITY,
+        {
+          packageId: "clock",
+          capabilityId: "clock",
+          kind: "tool",
+        },
+      ],
+    });
+
+    expect(same).toBe(first);
+    expect(otherUser).not.toBe(first);
+    expect(otherBot).not.toBe(first);
+    expect(otherGeneration).not.toBe(first);
+    expect(widened).not.toBe(first);
+  });
+
+  test("ordering does not change the digest", async () => {
+    const clock: IsolateCapabilityV1 = {
+      packageId: "clock",
+      capabilityId: "clock",
+      kind: "tool",
+    };
+
+    await expect(
+      isolateBindingDigestV1({
+        userId: "user-1",
+        botId: "bot-1",
+        generationId: "generation-1",
+        capabilities: [CAPABILITY, clock],
+      }),
+    ).resolves.toBe(
+      await isolateBindingDigestV1({
+        userId: "user-1",
+        botId: "bot-1",
+        generationId: "generation-1",
+        capabilities: [clock, CAPABILITY],
+      }),
+    );
+  });
+});
+
 describe("the isolate model request record", () => {
   test("two invocations reusing one Bot request id produce two records", async () => {
     const subject = host();