@frockbot/plugin-shell 0.3.2 → 0.3.3

package/src/client/index.test.ts

@@ -974,6 +974,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 +2697,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 &&
@@ -1156,6 +1221,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 +2277,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 +2301,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 +2314,7 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
           text: "",
           at: optimisticAt,
           status: "streaming",
+          ...(observed ? { pending: true } : {}),
           tools: [],
           sends: [],
         },
@@ -2257,6 +2335,7 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
           requestController.signal,
           pendingRunId,
           skills,
+          supersedes,
         );
         if (
           generation !== selectionGeneration ||
@@ -2385,7 +2464,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/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;

package/src/run-protocol.test.ts

@@ -416,6 +416,46 @@ describe("client run protocol v1", () => {
       }),
     ).toThrow("turn command.schemaVersion is invalid");
 
+    // Supersede intent is carried by the field's presence. The composer sends
+    // it on every send, and names a run only when it observed one.
+    expect(
+      decodeClientTurnCommandV1({
+        schemaVersion: 1,
+        commandId: "command-1",
+        text: "hello",
+        supersedes: {},
+      }),
+    ).toEqual({
+      schemaVersion: 1,
+      commandId: "command-1",
+      text: "hello",
+      supersedes: {},
+    });
+    expect(
+      decodeClientTurnCommandV1({
+        schemaVersion: 1,
+        commandId: "command-1",
+        text: "hello",
+        supersedes: { runId: "run-1" },
+      }).supersedes,
+    ).toEqual({ runId: "run-1" });
+    expect(() =>
+      decodeClientTurnCommandV1({
+        schemaVersion: 1,
+        commandId: "command-1",
+        text: "hello",
+        supersedes: { runId: "not a run id" },
+      }),
+    ).toThrow("turn command.supersedes.runId is invalid");
+    expect(() =>
+      decodeClientTurnCommandV1({
+        schemaVersion: 1,
+        commandId: "command-1",
+        text: "hello",
+        supersedes: { runId: "run-1", extra: 1 },
+      }),
+    ).toThrow();
+
     expect(
       decodeClientNotificationAcknowledgementCommandV1({
         schemaVersion: 1,
@@ -571,6 +611,58 @@ describe("client run protocol v1", () => {
     }
   });
 
+  test("projects dynamic call identity so the client can show the inner tool", () => {
+    const projected = projectClientTurnV1({
+      runId: "run-dynamic-tool",
+      text: "",
+      events: [
+        event({
+          type: "tool/call",
+          seq: 0,
+          timestamp,
+          turn: 1,
+          step: 1,
+          occurrenceId: "tool:1:1:0",
+          name: "call_dynamic_tool",
+          input: {
+            namespace: "user-Github--acme",
+            toolName: "search_issues",
+            arguments: { query: "is:open" },
+            mcpDetails: { description: "Find open issues." },
+          },
+        }),
+        event({
+          type: "tool/result",
+          seq: 1,
+          timestamp,
+          turn: 1,
+          step: 1,
+          occurrenceId: "tool:1:1:0",
+          name: "call_dynamic_tool",
+          content: "[]",
+          isError: false,
+          status: "completed",
+        }),
+      ],
+    });
+
+    expect(projected.events[0]).toEqual({
+      type: "tool/call",
+      call: {
+        id: "tool-1",
+        name: "call_dynamic_tool",
+        input: {
+          namespace: "user-Github--acme",
+          toolName: "search_issues",
+          argumentsJson: '{"query":"is:open"}',
+        },
+      },
+    });
+    expect(decodeClientTurnV1(structuredClone(projected)).events[0]).toEqual(
+      projected.events[0],
+    );
+  });
+
   test("projects only bounded user-visible run state", () => {
     const stored = {
       runId: "run-1",