@frockbot/plugin-shell 0.3.2 → 0.3.4

package/src/client/index.test.ts

@@ -826,6 +826,84 @@ describe("Bot selection", () => {
     },
   );
 
+  /**
+   * The composer placeholder and the not-ready line in `FrockBotApp.vue` are
+   * `state.modelLabel`, so a genuinely broken binding has to reach that label
+   * as the resolver's own repairable sentence rather than a flat "Model
+   * unavailable" the User cannot act on.
+   */
+  test("labels a Bot whose model Connection is disabled with the resolver's failure", async () => {
+    let provided: Ref<FrockBotWebData> | undefined;
+    const bot = initializeBotSettingsV1("broken-model-bot");
+    const user: UserSettingsViewV1 = {
+      schemaVersion: 1,
+      revision: 1,
+      profile: { name: "User" },
+      packages: [
+        { packageId: "model-provider", version: "0.0.1", state: "installed" },
+      ],
+      connections: [
+        {
+          connectionId: "model-connection",
+          packageId: "model-provider",
+          connectionTypeId: "model-account",
+          displayName: "Work",
+          state: "disabled",
+          providerType: "model-provider",
+          safeMetadata: {},
+        },
+      ],
+      platformModel: {
+        connectionId: "model-connection",
+        providerModelId: "model-id",
+      },
+    };
+    await shellClientPlugin({
+      transport: {
+        turn: () => Promise.resolve({ runId: "run", text: "", events: [] }),
+        readConfiguration: (query) =>
+          Promise.resolve(query.type === "user/get" ? user : bot),
+      },
+      slot: () => () => {},
+      inject: () => {
+        throw new Error("unexpected client provider injection");
+      },
+      provide: (_key, value) => {
+        provided = value as Ref<FrockBotWebData>;
+        return () => {};
+      },
+    });
+    if (!provided) throw new Error("shell data was not provided");
+    provided.value.activeBotId = bot.botId;
+    provided.value.pluginCatalog = [
+      {
+        packageId: "model-provider",
+        displayName: "Model provider",
+        version: "0.0.1",
+        capabilities: [
+          { id: "models", kind: "model", connectionTypes: ["model-account"] },
+        ],
+        connectionTypes: [
+          {
+            id: "model-account",
+            displayName: "Model account",
+            allowMultiple: false,
+            authorizationKind: "api-key",
+            capabilities: ["models"],
+          },
+        ],
+        settings: [],
+      },
+    ];
+
+    await provided.value.loadBotSettings();
+
+    expect(provided.value.modelReady).toBe(false);
+    expect(provided.value.modelLabel).toBe(
+      'Connection "model-connection" is disabled; enable or reconnect it',
+    );
+  });
+
   test("saves Bot-scoped Package settings through the generic command", async () => {
     type PackageSettingsWebData = FrockBotWebData & {
       saveBotPackageSettings(
@@ -974,6 +1052,52 @@ describe("Bot selection", () => {
 });
 
 describe("detached Turn projection", () => {
+  test("shows a dynamic call as its namespace/tool with inner arguments", () => {
+    const messages: Parameters<typeof projectCompletedRuns>[0] = [];
+    projectCompletedRuns(
+      messages,
+      [],
+      [
+        {
+          runId: "run-dynamic",
+          input: "Find open issues",
+          status: "completed",
+          responseText: "Done",
+          events: [
+            {
+              type: "tool/call",
+              call: {
+                id: "tool-1",
+                name: "call_dynamic_tool",
+                input: {
+                  namespace: "user-Github--acme",
+                  toolName: "search_issues",
+                  argumentsJson: '{"query":"is:open"}',
+                },
+              },
+            },
+            {
+              type: "tool/result",
+              callId: "tool-1",
+              content: "[]",
+              isError: false,
+            },
+          ],
+        },
+      ],
+    );
+
+    expect(messages[1]?.tools).toEqual([
+      {
+        id: "tool-1",
+        name: "user-Github--acme/search_issues",
+        input: { query: "is:open" },
+        status: "completed",
+        text: "[]",
+      },
+    ]);
+  });
+
   test("projects a completed run before it can be acknowledged", () => {
     const messages: Parameters<typeof projectCompletedRuns>[0] = [];
     const projected = projectCompletedRuns(
@@ -2651,3 +2775,165 @@ describe("Connection operation reconciliation", () => {
     expect(commandIds[1]).not.toBe(commandIds[0]);
   });
 });
+
+describe("a message sent while a Turn is running", () => {
+  test("is accepted, and carries the intent to supersede what is running", async () => {
+    Object.defineProperty(globalThis, "window", {
+      configurable: true,
+      value: {
+        location: { href: "https://app.example/?bot=primary" },
+        history: { replaceState: () => undefined },
+      },
+    });
+    let provided: Ref<FrockBotWebData> | undefined;
+    const sent: {
+      text: string;
+      supersedes?: { runId?: string };
+    }[] = [];
+    let releaseFirst!: () => void;
+    const firstTurn = new Promise<void>((resolve) => {
+      releaseFirst = resolve;
+    });
+    await shellClientPlugin({
+      transport: {
+        turn: async (_botId, text, _signal, commandId, _skills, supersedes) => {
+          sent.push({ text, ...(supersedes ? { supersedes } : {}) });
+          if (sent.length === 1) await firstTurn;
+          return { runId: commandId, text: `answer to ${text}`, events: [] };
+        },
+        readConfiguration: () =>
+          Promise.resolve(initializeBotSettingsV1("primary")),
+        listRuns: () => Promise.resolve([]),
+        listNotifications: () => Promise.resolve([]),
+      },
+      slot: () => () => {},
+      inject: () => {
+        throw new Error("unexpected client provider injection");
+      },
+      provide: (_key, value) => {
+        provided = value as Ref<FrockBotWebData>;
+        return () => {};
+      },
+    });
+    if (!provided) throw new Error("shell data was not provided");
+    provided.value.activeBotId = "primary";
+    provided.value.composerContext = "primary";
+
+    const first = provided.value.sendPrompt("first");
+    await Promise.resolve();
+    const runningRunId = provided.value.activeRunId;
+    expect(runningRunId).toBeString();
+
+    // The composer is open while a Turn runs, and what it sends replaces it.
+    const second = provided.value.sendPrompt("second");
+    releaseFirst();
+    expect(await first).toMatchObject({ accepted: true });
+    expect(await second).toMatchObject({ accepted: true });
+
+    expect(sent.map((entry) => entry.text).sort()).toEqual(["first", "second"]);
+    // Every send carries the intent. The first had observed no run, so it
+    // carries no provenance — and that is exactly the send that used to be
+    // refused when a person typed faster than the client could observe the
+    // Turn it had just started.
+    expect(sent.find((entry) => entry.text === "first")?.supersedes).toEqual(
+      {},
+    );
+    expect(sent.find((entry) => entry.text === "second")?.supersedes).toEqual({
+      runId: runningRunId!,
+    });
+  });
+
+  test("greys the queued Turn, and un-greys it when it starts", () => {
+    const state: Pick<
+      FrockBotWebData,
+      "messages" | "activeRunId" | "runningRunId" | "activeRun"
+    > = { messages: [] };
+
+    projectDurableRuns(
+      state,
+      [],
+      [
+        { runId: "run-1", input: "first", events: [], status: "running" },
+        {
+          runId: "run-2",
+          input: "second",
+          events: [],
+          status: "running",
+          queued: true,
+        },
+      ],
+    );
+
+    // Ordinary messages; the waiting one is simply held back.
+    expect(state.messages.map((message) => message.pending)).toEqual([
+      undefined,
+      undefined,
+      true,
+      true,
+    ]);
+    // A new message supersedes the newest unsettled Turn; Stop cancels the one
+    // that is actually executing.
+    expect(state.activeRunId).toBe("run-2");
+    expect(state.runningRunId).toBe("run-1");
+
+    projectDurableRuns(
+      state,
+      [],
+      [
+        {
+          runId: "run-1",
+          input: "first",
+          events: [],
+          status: "superseded",
+          failure: "Interrupted by your next message.",
+        },
+        { runId: "run-2", input: "second", events: [], status: "running" },
+      ],
+    );
+
+    expect(state.messages.every((message) => !message.pending)).toBe(true);
+    expect(state.activeRunId).toBe("run-2");
+    expect(state.runningRunId).toBe("run-2");
+    // The superseded Turn keeps the quiet treatment a stopped one gets.
+    expect(state.messages[1]).toMatchObject({
+      status: "aborted",
+      text: "Interrupted by your next message.",
+    });
+  });
+
+  test("a reload reconstructs the greyed state from durable runs alone", () => {
+    const reloaded: Pick<
+      FrockBotWebData,
+      "messages" | "activeRunId" | "runningRunId" | "activeRun"
+    > = { messages: [] };
+
+    projectDurableRuns(
+      reloaded,
+      [],
+      [
+        {
+          runId: "run-1",
+          input: "first",
+          events: [],
+          status: "superseded",
+          failure: "Interrupted by your next message.",
+        },
+        {
+          runId: "run-2",
+          input: "second",
+          events: [],
+          status: "running",
+          queued: true,
+        },
+      ],
+    );
+
+    expect(reloaded.messages[2]).toMatchObject({
+      role: "user",
+      text: "second",
+      pending: true,
+    });
+    expect(reloaded.runningRunId).toBeUndefined();
+    expect(reloaded.activeRunId).toBe("run-2");
+  });
+});

package/src/client/index.ts

@@ -98,13 +98,49 @@ import "@frockbot/client-core/fonts.css";
 import "./styles.css";
 import { defineClientContribution } from "@frockbot/kernel-contracts/contributions";
 
+function presentedToolCall(call: NonNullable<ClientTurnEvent["call"]>): {
+  name: string;
+  input?: unknown;
+} {
+  if (
+    call.name === "call_dynamic_tool" &&
+    typeof call.input === "object" &&
+    call.input !== null &&
+    !Array.isArray(call.input)
+  ) {
+    const input = call.input as Record<string, unknown>;
+    if (
+      typeof input.namespace === "string" &&
+      typeof input.toolName === "string"
+    ) {
+      let innerArguments: unknown = {};
+      if (typeof input.argumentsJson === "string") {
+        try {
+          innerArguments = JSON.parse(input.argumentsJson) as unknown;
+        } catch {
+          innerArguments = {};
+        }
+      }
+      return {
+        name: `${input.namespace}/${input.toolName}`,
+        input: innerArguments,
+      };
+    }
+  }
+  return {
+    name: call.name,
+    ...(call.input === undefined ? {} : { input: call.input }),
+  };
+}
+
 function toolsFrom(events: ClientTurnEvent[]): WebToolActivity[] {
   const tools = new Map<string, WebToolActivity>();
   for (const event of events) {
     if (event.type === "tool/call" && event.call) {
+      const presented = presentedToolCall(event.call);
       tools.set(event.call.id, {
         id: event.call.id,
-        name: event.call.name,
+        ...presented,
         status: "running",
       });
     }
@@ -179,7 +215,7 @@ function tasksFrom(events: ClientTurnEvent[]): WebTaskChip[] {
 
 type DurableRunProjectionState = Pick<
   FrockBotWebData,
-  "messages" | "activeRunId" | "activeRun" | "error"
+  "messages" | "activeRunId" | "runningRunId" | "activeRun" | "error"
 >;
 
 /**
@@ -218,7 +254,8 @@ function isTerminalRun(run: ClientRun): boolean {
   return (
     run.status === "completed" ||
     run.status === "failed" ||
-    run.status === "cancelled"
+    run.status === "cancelled" ||
+    run.status === "superseded"
   );
 }
 
@@ -235,6 +272,23 @@ function assistantMessage(
       role: "assistant",
       text: run.responseText ?? "",
       status: "streaming",
+      // A Turn that has not started shows nothing of its own: the greyed user
+      // message is the whole of what the thread says about it.
+      ...(run.queued ? { pending: true } : {}),
+      tools: toolsFrom(run.events),
+      sends: sendsFrom(run.events),
+      tasks: tasksFrom(run.events),
+    };
+  }
+  if (run.status === "superseded") {
+    // The same quiet treatment a stopped Turn gets. It keeps everything it
+    // already sent; the line only says why it ends where it does.
+    return {
+      id: `${run.runId}:assistant`,
+      runId: run.runId,
+      role: "assistant",
+      text: run.failure ?? "Interrupted by your next message.",
+      status: "aborted",
       tools: toolsFrom(run.events),
       sends: sendsFrom(run.events),
       tasks: tasksFrom(run.events),
@@ -321,6 +375,9 @@ export function projectDurableRuns(
   // Busy state and the banner are separate: a running Turn keeps the composer
   // busy without producing a banner of its own.
   let busyRunId: string | undefined;
+  // The Turn Stop targets: the one that is executing, never the one waiting
+  // behind it.
+  let runningRunId: string | undefined;
   for (const run of runs) {
     const notification = notifications.find(
       (candidate) => candidate.runId === run.runId,
@@ -340,6 +397,9 @@ export function projectDurableRuns(
           ? { at: existingUser.at }
           : {}),
       status: "completed",
+      // Greyed while its Turn waits, ordinary the moment it is running. The
+      // flag comes from durable run state, so a reload draws the same thing.
+      ...(run.queued ? { pending: true } : {}),
       tools: [],
       sends: [],
     };
@@ -360,6 +420,7 @@ export function projectDurableRuns(
     activeRun = activeRunView(run) ?? activeRun;
     if (run.status === "running" || run.status === "reconciliation-required") {
       busyRunId = run.runId;
+      if (!run.queued) runningRunId = run.runId;
     }
     if (notification && isTerminalRun(run)) {
       projected.add(notification.notificationId);
@@ -377,6 +438,10 @@ export function projectDurableRuns(
   else if (state.activeRunId && terminalRunIds.has(state.activeRunId)) {
     state.activeRunId = undefined;
   }
+  if (runningRunId) state.runningRunId = runningRunId;
+  else if (state.runningRunId && terminalRunIds.has(state.runningRunId)) {
+    state.runningRunId = undefined;
+  }
   if (activeRun) state.activeRun = activeRun;
   else if (
     state.activeRun &&
@@ -1023,14 +1088,18 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
   function updateModelLabel(): void {
     const bot = web.value.botSettings;
     const user = web.value.userSettings;
-    if (!bot || !user) {
+    if (!user) {
       web.value.modelSource = "none";
       web.value.modelReady = false;
       web.value.modelLabel = modelRuntimeLabel({ source: "none" });
       return;
     }
     const effective = resolveEffectiveBotModelV1({
-      bot: toRaw(bot),
+      // Before the first Bot exists — and in the window before a selected
+      // Bot's settings arrive — the account's own effective model is still
+      // the truth. An empty Bot scope simply declines to override it, so the
+      // shell reports the account model instead of claiming it is unavailable.
+      bot: bot ? toRaw(bot) : { packageValues: {} },
       user: toRaw(user),
       packages: toRaw(web.value.pluginCatalog).map((pkg) => ({
         packageId: pkg.packageId,
@@ -1156,6 +1225,7 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
       web.value.messages = [];
       web.value.activeRun = undefined;
       web.value.activeRunId = undefined;
+      web.value.runningRunId = undefined;
       web.value.skillCatalog = [];
       web.value.approvals = [];
       web.value.tasks = [];
@@ -2211,12 +2281,20 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
       text: string,
       skills?: readonly SkillRefV1[],
     ): Promise<SendPromptResult> {
-      if (web.value.activeRunId) return { accepted: false, error: "busy" };
       const botId = web.value.activeBotId;
       if (!botId) return { accepted: false, error: "no-bot" };
       const generation = selectionGeneration;
       const pendingRunId = crypto.randomUUID();
       const optimisticAt = new Date().toISOString();
+      // Every send carries the intent, because "do this instead" is what a
+      // person means by pressing send and it does not depend on what this
+      // client had managed to observe first. Whether a run was showing as
+      // active is a race — the composer unlocks the instant a Turn settles,
+      // and a fast typist beats the next poll — so gating the intent on
+      // `activeRunId` made the Bot refuse a message the User had every right
+      // to send. The observed run rides along as provenance when there is one.
+      const observed = web.value.activeRunId;
+      const supersedes = observed ? { runId: observed } : {};
       web.value.activeRunId = pendingRunId;
       web.value.error = undefined;
       web.value.messages.push(
@@ -2227,6 +2305,9 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
           text,
           at: optimisticAt,
           status: "completed",
+          // Greyed until its own Turn is admitted and running. Optimistic
+          // only: the durable projection replaces it by run id.
+          ...(observed ? { pending: true } : {}),
           tools: [],
           sends: [],
         },
@@ -2237,6 +2318,7 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
           text: "",
           at: optimisticAt,
           status: "streaming",
+          ...(observed ? { pending: true } : {}),
           tools: [],
           sends: [],
         },
@@ -2257,6 +2339,7 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
           requestController.signal,
           pendingRunId,
           skills,
+          supersedes,
         );
         if (
           generation !== selectionGeneration ||
@@ -2385,7 +2468,13 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
     },
     async stopRun(): Promise<void> {
       const botId = web.value.activeBotId;
-      const runId = web.value.activeRun?.runId ?? web.value.activeRunId;
+      // The Turn that is executing, never the message waiting behind it: Stop
+      // cancels what the Bot is doing and does not discard what the User just
+      // sent.
+      const runId =
+        web.value.activeRun?.runId ??
+        web.value.runningRunId ??
+        web.value.activeRunId;
       if (!botId || !runId) return;
       if (!ctx.transport.stopRun) {
         web.value.settingsError = "Stop is unavailable";

package/src/client/no-bot-model-label.test.ts

@@ -0,0 +1,122 @@
+import { plugin } from "bun";
+import { expect, test } from "bun:test";
+import type { UserSettingsViewV1 } from "@frockbot/configuration-core";
+import type { Ref } from "vue";
+import type { FrockBotWebData } from "../shared.js";
+
+// Bun has no single-file-component loader; the shell's Vue modules stand in as
+// empty components, exactly as `index.test.ts` does.
+plugin({
+  name: "shell-client-vue-no-bot-loader",
+  setup(build) {
+    build.onLoad({ filter: /\.vue$/ }, () => ({
+      contents: "export default {};",
+      loader: "js",
+    }));
+  },
+});
+
+const { shellClientPlugin } = await import("./index.js");
+
+/**
+ * A first-run account: the platform model resolves against a ready ambient
+ * Flock AI Connection whose Catalog is fresh, and no Bot has been created yet.
+ * The account's model is available, so the shell must not tell the User it is
+ * unavailable before they have made their first Bot.
+ */
+test("does not report the account model unavailable before a Bot exists", async () => {
+  const user: UserSettingsViewV1 = {
+    schemaVersion: 1,
+    revision: 3,
+    profile: { name: "FrockBot user" },
+    packages: [
+      { packageId: "provider-flock-ai", version: "0.0.1", state: "installed" },
+    ],
+    connections: [
+      {
+        connectionId: "flock-ai-ambient",
+        packageId: "provider-flock-ai",
+        connectionTypeId: "flock-ai-account",
+        displayName: "Flock AI",
+        state: "ready",
+        providerType: "flock-ai",
+        safeMetadata: {},
+        modelCatalog: {
+          schemaVersion: 1,
+          generation: "flock-ai-static-v1",
+          state: "fresh",
+          models: [
+            {
+              providerModelId: "@flock/auto",
+              displayName: "Auto (recommended)",
+              capabilities: { tools: true, vision: false, reasoning: true },
+              source: "discovered",
+            },
+          ],
+        },
+      },
+    ],
+    platformModel: {
+      connectionId: "flock-ai-ambient",
+      providerModelId: "@flock/auto",
+    },
+  };
+
+  let provided: Ref<FrockBotWebData> | undefined;
+  await shellClientPlugin({
+    transport: {
+      turn: () => Promise.resolve({ runId: "run", text: "", events: [] }),
+      readApplicationManifest: () =>
+        Promise.resolve({
+          schemaVersion: 1,
+          deployment: { userId: "development", applicationHash: "hash-1" },
+          applicationHash: "hash-1",
+          packages: [
+            {
+              id: "provider-flock-ai",
+              displayName: "Flock AI",
+              version: "0.0.1",
+              contributions: ["backend", "runtime"],
+              configuration: {
+                settings: [],
+                connectionTypes: [
+                  {
+                    id: "flock-ai-account",
+                    displayName: "Flock AI",
+                    allowMultiple: false,
+                    authorization: { kind: "ambient-native" },
+                    capabilities: ["flock-ai-models"],
+                  },
+                ],
+                capabilities: [
+                  {
+                    id: "flock-ai-models",
+                    kind: "model",
+                    connectionTypes: ["flock-ai-account"],
+                    admission: { turnTypes: ["chat"] },
+                  },
+                ],
+              },
+            },
+          ],
+        }),
+      readConfiguration: () => Promise.resolve(user),
+    },
+    slot: () => () => {},
+    inject: () => {
+      throw new Error("unexpected client provider injection");
+    },
+    provide: (_key, value) => {
+      provided = value as Ref<FrockBotWebData>;
+      return () => {};
+    },
+  });
+  if (!provided) throw new Error("shell data was not provided");
+
+  await provided.value.loadPluginCatalog();
+
+  // No Bot has been created, so `activeBotId` is unset.
+  expect(provided.value.activeBotId).toBeUndefined();
+  expect(provided.value.modelLabel).toBe("Auto (recommended) · Flock AI");
+  expect(provided.value.modelReady).toBe(true);
+});

package/src/client/styles.css

@@ -263,6 +263,17 @@
   margin-top: 18px;
 }
 
+/*
+ * A message the User sent while the Bot was still working. It is an ordinary
+ * message the Bot has not reached yet, so it is drawn as one and simply held
+ * back — no label, no icon, no word for the User to learn. It goes to full
+ * strength the moment its own Turn starts.
+ */
+.message-pending {
+  opacity: 0.55;
+  transition: opacity var(--frock-motion-enter);
+}
+
 /* A Session announcement: the conversation narrating itself, not a party. */
 .message-system {
   align-items: center;