@mercury-fw/channel-google-chat 0.8.0 → 0.8.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @mercury-fw/channel-google-chat
 
+## 0.8.2
+
+### Patch Changes
+
+- edfebb5: - `@mercury-fw/plugin-web-search`: an answer no longer lists its sources twice. When the model writes its own list of sources at the end of the answer, the plugin's `Fonti:` list replaces it, and `web_fetch`'s description tells the model the pages it reads are listed for it.
+  - `@mercury-fw/channel-google-chat`: once a choice on a confirmation card is taken, the card shows it ("Scelto: …") instead of the buttons. A click that confirms nothing (expired, or someone else's in a shared space) leaves the card as it is.
+  - `@mercury-fw/channel-types`: `confirmReply(outcome)`, the reply to each confirmation outcome, for a channel that resolves a token through `resolveConfirmation`.
+  - `@mercury-fw/confirm-engine`: `tryConfirm` answers with `confirmReply`, same texts as before.
+
+## 0.8.1
+
+### Patch Changes
+
+- 4431285: - plugin-web-search README: the minimum core (0.53), the Italian labels the person reads, where a person's list lives and how to edit it, and a config example matching the app `mfw create` writes.
+  - channel-google-chat README: the confirmation card has a button per choice, and a choice whose result goes back to the model runs the turn again.
+
 ## 0.8.0
 
 ### Minor Changes

package/README.md

@@ -28,6 +28,8 @@ Each message reaches the core as `google-chat:users/<id>`, the sender's Chat use
 
 When a plugin that acts as the person (Jira, Bitbucket) needs them to log in, the channel sends a card with a button that opens the service's login, visible only to that person: in a direct message the space is already theirs, in a shared space the card is a private message to whoever asked, since anyone else opening it would log their own account in as them. The service sends the browser back to the HTTP channel's `/login/callback`, so the app needs [`@mercury-fw/channel-http`](https://www.npmjs.com/package/@mercury-fw/channel-http) with `HTTP_SURFACE_PUBLIC_URL` too; without it Mercury answers that nobody can log in on this instance.
 
+When a tool stages an action that needs confirming, the channel sends a card with the action and a button per choice the tool offers: one `Conferma` for a plain staging (deleting a Jira issue, say), more when there's a choice to make (the web search plugin offers "Solo questa volta" and "Sempre per \<host\>" before reading a page on a host nobody allowed). Clicking a button confirms that choice and the others die with it, and the card shows the choice taken instead of the buttons; typing the token in the conversation does the same, leaving the card as it is. A click that confirms nothing (the request expired, or in a shared space it's someone else's) leaves the card for whoever has to choose. When the confirmed action's result goes back to the model (a page read after the person allowed it), the channel runs the conversation's turn again instead of sending the raw result, so the answer comes from the model, built on what came back.
+
 ## Table of contents
 
 - [Setting up the Chat app](#setting-up-the-chat-app)

package/dist/google-chat-provider.d.ts

@@ -21,7 +21,7 @@
  */
 import { sendMessage, sendCard, updateCard, getOrCreateDmSpace, type ServiceAccountCredentials, type TokenSource } from "./google-chat-app-client.ts";
 import { type PubSubSubscription } from "./google-chat-pubsub-stream.ts";
-import { type Provider, type Principal } from "@mercury-fw/channel-types";
+import { type ConfirmOutcome, type Provider, type Principal } from "@mercury-fw/channel-types";
 /**
  * Composite session key: space + sender. Deliberately does NOT include
  * `thread` — confirmed live (two consecutive messages in the same DM
@@ -54,6 +54,8 @@ export type ParsedMessageEvent = {
 };
 export type ParsedCardClickEvent = {
     kind: "card-click";
+    /** The message holding the clicked card, when the event names it. */
+    messageName?: string;
     space: string;
     sender: string;
     senderEmail: string | undefined;
@@ -63,18 +65,25 @@ export type ParsedCardClickEvent = {
 };
 /** Parses one decoded Pub/Sub event, or `null` if it isn't a kind this provider acts on. */
 export declare function parseChatEvent(raw: unknown): ParsedMessageEvent | ParsedCardClickEvent | null;
-export type CardClickHandler = (params: Record<string, string>, space: string, sender: string, senderEmail?: string, isDirectMessage?: boolean) => Promise<void>;
+export type CardClickHandler = (params: Record<string, string>, space: string, sender: string, senderEmail?: string, isDirectMessage?: boolean, messageName?: string) => Promise<void>;
 export type GoogleChatProviderDeps = {
     credentials: ServiceAccountCredentials;
     subscription: string;
     /**
      * Resolves a confirmation token against the core's shared store, injected by
      * the channel loader (`ChannelRuntimeContext.confirm`). Returns the reply to
-     * send, or `null` when the input wasn't token-shaped. This is the whole of
-     * the channel's contact with confirmation — the store, vault and note-writer
-     * stay in the core.
+     * send, or `null` when the input wasn't token-shaped. With
+     * `resolveConfirmation` below, the channel's whole contact with confirmation:
+     * the store, vault and note-writer stay in the core.
      */
     confirm: (token: string, sessionKey: string, principal: Principal) => Promise<string | null>;
+    /**
+     * The structured sibling of `confirm` (`ChannelRuntimeContext.resolveConfirmation`).
+     * When it's there, a click resolves through it, and an accepted choice
+     * turns its card into the choice taken; without it, a click goes through
+     * `confirm` and the card stays as it was.
+     */
+    resolveConfirmation?: (token: string, sessionKey: string, principal: Principal) => Promise<ConfirmOutcome>;
     /**
      * Handles a `CARD_CLICKED` event's action parameters. Defaults to resolving
      * the confirm button's token through `deps.confirm` (the same path a bare

package/google-chat-provider.ts

@@ -37,6 +37,8 @@ import {
   loginLinkText,
   PENDING_CONFIRMATION_NOTE,
   RESUME_AFTER_CONFIRM,
+  confirmReply,
+  type ConfirmOutcome,
   NO_REPLY,
   type LoginRequest,
   type PendingConfirmation,
@@ -53,7 +55,9 @@ import {
  * (a single `Conferma` for a plain staging). Each button's parameters carry
  * the token, so a click routes straight into the same `tryConfirm` path
  * a bare token typed on the terminal uses (see `onCardClick`'s `confirm`
- * case, below) — the user never has to see or type the token themselves.
+ * case, below) — the user never has to see or type the token themselves —
+ * plus its label and the summary, so the click can turn the card into
+ * `buildChosenCard` without the channel keeping any state.
  */
 function buildConfirmCard(pending: PendingConfirmation): ChatCard {
   return {
@@ -66,7 +70,16 @@ function buildConfirmCard(pending: PendingConfirmation): ChatCard {
             buttonList: {
               buttons: pending.choices.map((choice) => ({
                 text: choice.label,
-                onClick: { action: { function: "confirm", parameters: [{ key: "token", value: choice.token }] } },
+                onClick: {
+                  action: {
+                    function: "confirm",
+                    parameters: [
+                      { key: "token", value: choice.token },
+                      { key: "label", value: choice.label },
+                      { key: "summary", value: pending.summary },
+                    ],
+                  },
+                },
               })),
             },
           },
@@ -76,6 +89,21 @@ function buildConfirmCard(pending: PendingConfirmation): ChatCard {
   };
 }
 
+/** The confirmation card once a choice is taken: the same request, the choice instead of the buttons. */
+function buildChosenCard(summary: string, label: string | undefined): ChatCard {
+  return {
+    header: { title: "Conferma richiesta" },
+    sections: [
+      {
+        widgets: [
+          { textParagraph: { text: `\`${summary}\`` } },
+          { textParagraph: { text: label === undefined ? "Scelta registrata." : `Scelto: ${label}` } },
+        ],
+      },
+    ],
+  };
+}
+
 /** The card that shows a person the link to log in to a service a plugin acts on as them: one button that opens it. */
 function buildLoginCard(login: LoginRequest): ChatCard {
   return {
@@ -221,6 +249,8 @@ export type ParsedMessageEvent = {
 
 export type ParsedCardClickEvent = {
   kind: "card-click";
+  /** The message holding the clicked card, when the event names it. */
+  messageName?: string;
   space: string;
   sender: string;
   senderEmail: string | undefined;
@@ -264,6 +294,7 @@ export function parseChatEvent(raw: unknown): ParsedMessageEvent | ParsedCardCli
     }
     return {
       kind: "card-click",
+      ...(typeof event.message?.name === "string" ? { messageName: event.message.name } : {}),
       space: event.space.name,
       sender: event.user.name,
       senderEmail: emailOf(event.user),
@@ -280,6 +311,7 @@ export type CardClickHandler = (
   sender: string,
   senderEmail?: string,
   isDirectMessage?: boolean,
+  messageName?: string,
 ) => Promise<void>;
 
 export type GoogleChatProviderDeps = {
@@ -288,11 +320,18 @@ export type GoogleChatProviderDeps = {
   /**
    * Resolves a confirmation token against the core's shared store, injected by
    * the channel loader (`ChannelRuntimeContext.confirm`). Returns the reply to
-   * send, or `null` when the input wasn't token-shaped. This is the whole of
-   * the channel's contact with confirmation — the store, vault and note-writer
-   * stay in the core.
+   * send, or `null` when the input wasn't token-shaped. With
+   * `resolveConfirmation` below, the channel's whole contact with confirmation:
+   * the store, vault and note-writer stay in the core.
    */
   confirm: (token: string, sessionKey: string, principal: Principal) => Promise<string | null>;
+  /**
+   * The structured sibling of `confirm` (`ChannelRuntimeContext.resolveConfirmation`).
+   * When it's there, a click resolves through it, and an accepted choice
+   * turns its card into the choice taken; without it, a click goes through
+   * `confirm` and the card stays as it was.
+   */
+  resolveConfirmation?: (token: string, sessionKey: string, principal: Principal) => Promise<ConfirmOutcome>;
   /**
    * Handles a `CARD_CLICKED` event's action parameters. Defaults to resolving
    * the confirm button's token through `deps.confirm` (the same path a bare
@@ -383,11 +422,14 @@ export function createGoogleChatProvider(deps: GoogleChatProviderDeps): GoogleCh
    * Default `onCardClick`: the confirm button's token routes through the exact
    * same `deps.confirm` a bare token typed on the terminal uses — one execution
    * path, one set of valid/expired/wrong-session-token behaviors, regardless of
-   * how the token got here.
+   * how the token got here. A click the core accepted (the action ran, failed,
+   * or the turn resumes) turns its card into the choice taken, before
+   * anything else; one it didn't (`not-found`: expired, used, or someone
+   * else's in a shared space) leaves the card for whoever has to choose.
    */
   const onCardClick: CardClickHandler =
     deps.onCardClick ??
-    (async (params, space, sender, senderEmail, isDirectMessage = false) => {
+    (async (params, space, sender, senderEmail, isDirectMessage = false, messageName) => {
       const token = params.token;
       if (!token) {
         log(`[chat] card click with no token parameter`);
@@ -398,7 +440,26 @@ export function createGoogleChatProvider(deps: GoogleChatProviderDeps): GoogleCh
         provider: "google-chat",
         ...(senderEmail === undefined ? {} : { claims: { email: senderEmail } }),
       };
-      const reply = await deps.confirm(token, deriveSessionKey(space, sender), principal);
+      const sessionKey = deriveSessionKey(space, sender);
+      let reply: string | null;
+      if (deps.resolveConfirmation) {
+        const outcome = await deps.resolveConfirmation(token, sessionKey, principal);
+        const accepted = outcome.status === "ok" || outcome.status === "failed" || outcome.status === "resume";
+        if (accepted && messageName !== undefined && params.summary !== undefined) {
+          try {
+            await updateCardFn(messageName, buildChosenCard(params.summary, params.label), clientDeps);
+            log(`[chat:${space}] [out] confirm card ${messageName} patched to the choice taken`);
+          } catch (err) {
+            log(`[chat:${space}] confirm card patch failed: ${String(err)}`);
+          }
+        }
+        // On not-found nothing was taken, so `confirm` gives the reply as it
+        // always did: the core's own message for someone it won't talk to,
+        // which the outcome doesn't carry.
+        reply = outcome.status === "not-found" ? await deps.confirm(token, sessionKey, principal) : confirmReply(outcome);
+      } else {
+        reply = await deps.confirm(token, sessionKey, principal);
+      }
       if (reply === RESUME_AFTER_CONFIRM && activeHandleTurn) {
         await resumeTurn(activeHandleTurn, space, principal, isDirectMessage);
         return;
@@ -648,7 +709,7 @@ export function createGoogleChatProvider(deps: GoogleChatProviderDeps): GoogleCh
       if (parsed.kind === "message") {
         await processMessageEvent(parsed, handleTurn);
       } else {
-        await onCardClick(parsed.parameters, parsed.space, parsed.sender, parsed.senderEmail, parsed.isDirectMessage);
+        await onCardClick(parsed.parameters, parsed.space, parsed.sender, parsed.senderEmail, parsed.isDirectMessage, parsed.messageName);
       }
     } catch (err) {
       log(`[chat] event handling failed: ${String(err)}`);

package/index.ts

@@ -39,6 +39,7 @@ export const googleChatChannel: ChannelPlugin = {
       },
       subscription,
       confirm: ctx.confirm,
+      ...(ctx.resolveConfirmation === undefined ? {} : { resolveConfirmation: ctx.resolveConfirmation }),
       log: ctx.log,
     });
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mercury-fw/channel-google-chat",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -31,10 +31,10 @@
     "@google-cloud/pubsub": "^5.3.1"
   },
   "peerDependencies": {
-    "@mercury-fw/channel-types": ">=0.51.0 <1.0.0"
+    "@mercury-fw/channel-types": ">=0.53.1 <1.0.0"
   },
   "devDependencies": {
-    "@mercury-fw/channel-types": "0.51.0",
+    "@mercury-fw/channel-types": "0.53.1",
     "@mercury-fw/typescript-config": "*",
     "@types/bun": "^1.4.2",
     "typescript": "^6.0.3"