microsoft · curtisman · Jun 20, 2025 · Jun 20, 2025
diff --git a/ts/packages/agentRpc/src/client.ts b/ts/packages/agentRpc/src/client.ts
@@ -113,7 +113,7 @@ function createOptionsRpc(channelProvider: ChannelProvider, name: string) {
     const optionsMap = createObjectMap();
     return {
         optionsMap,
-        rpc: createRpc(channel, {
+        rpc: createRpc(name, channel, {
             callback: async (param: {
                 id: number;
                 name: string;
@@ -399,7 +399,7 @@ export async function createAgentRpcClient(
         AgentCallFunctions,
         AgentContextInvokeFunctions,
         AgentContextCallFunctions
-    >(channel, agentContextInvokeHandlers, agentContextCallHandlers);
+    >(name, channel, agentContextInvokeHandlers, agentContextCallHandlers);
 
     // The shim needs to implement all the APIs regardless whether the actual agent
     // has that API.  We remove remove it the one that is not necessary below.

diff --git a/ts/packages/agentRpc/src/rpc.ts b/ts/packages/agentRpc/src/rpc.ts
@@ -3,10 +3,6 @@
 
 import registerDebug from "debug";
 
-const debugIn = registerDebug("typeagent:rpc:in");
-const debugOut = registerDebug("typeagent:rpc:out");
-const debugError = registerDebug("typeagent:rpc:error");
-
 import { RpcChannel } from "./common.js";
 
 type RpcFuncTypes<
@@ -35,10 +31,14 @@ export function createRpc<
     InvokeHandlers extends RpcInvokeFunctions = {},
     CallHandlers extends RpcCallFunctions = {},
 >(
+    name: string, // for debugging only.
     channel: RpcChannel,
     invokeHandlers?: InvokeHandlers,
     callHandlers?: CallHandlers,
 ): RpcReturn<InvokeTargetFunctions, CallTargetFunctions> {
+    const debugIn = registerDebug(`typeagent:${name}:rpc:in`);
+    const debugOut = registerDebug(`typeagent:${name}:rpc:out`);
+    const debugError = registerDebug(`typeagent:${name}:rpc:error`);
     const pending = new Map<
         number,
         {

diff --git a/ts/packages/agentRpc/src/server.ts b/ts/packages/agentRpc/src/server.ts
@@ -41,7 +41,7 @@ function createOptionsRpc(channelProvider: ChannelProvider, name: string) {
     const optionsChannel: RpcChannel = channelProvider.createChannel(
         `options:${name}`,
     );
-    return createRpc<OptionsFunctionCallBack>(optionsChannel);
+    return createRpc<OptionsFunctionCallBack>(name, optionsChannel);
 }
 
 function populateOptionsFunctions(
@@ -260,7 +260,7 @@ export function createAgentRpcServer(
         AgentContextCallFunctions,
         AgentInvokeFunctions,
         AgentCallFunctions
-    >(channel, agentInvokeHandlers, agentCallHandlers);
+    >(name, channel, agentInvokeHandlers, agentCallHandlers);
 
     function getStorage(contextId: number, session: boolean): Storage {
         const tokenCachePersistence: TokenCachePersistence = {

diff --git a/ts/packages/agents/browser/src/agent/actionHandler.mts b/ts/packages/agents/browser/src/agent/actionHandler.mts
@@ -79,6 +79,7 @@ import { openai, TextEmbeddingModel } from "aiclient";
 import { createExternalBrowserClient } from "./rpc/externalBrowserControlClient.mjs";
 
 const debug = registerDebug("typeagent:browser:action");
+const debugWebSocket = registerDebug("typeagent:browser:ws");
 
 export function instantiate(): AppAgent {
     return {
@@ -179,19 +180,20 @@ async function updateBrowserContext(
         const webSocket = await createWebSocket("browser", "dispatcher");
         if (webSocket) {
             context.agentContext.webSocket = webSocket;
-            context.agentContext.externalBrowserControl =
-                createExternalBrowserClient(webSocket);
+            const browserControls = createExternalBrowserClient(webSocket);
+            context.agentContext.externalBrowserControl = browserControls;
             context.agentContext.browserConnector = new BrowserConnector(
                 context,
             );
 
             webSocket.onclose = (event: object) => {
-                console.error("Browser webSocket connection closed.");
+                debugWebSocket("Browser webSocket connection closed.");
                 context.agentContext.webSocket = undefined;
             };
             webSocket.addEventListener("message", async (event: any) => {
                 const text = event.data.toString();
                 const data = JSON.parse(text);
+                debugWebSocket(`Received message from browser: ${text}`);
                 if (isWebAgentMessage(data)) {
                     await processWebAgentMessage(data, context);
                     return;
@@ -210,19 +212,24 @@ async function updateBrowserContext(
                             const targetTranslator = data.params.translator;
                             if (targetTranslator == "browser.crossword") {
                                 // initialize crossword state
-                                sendSiteTranslatorStatus(
-                                    targetTranslator,
-                                    "initializing",
-                                    context,
+                                browserControls.setAgentStatus(
+                                    true,
+                                    `Initializing ${targetTranslator}`,
                                 );
-                                context.agentContext.crossWordState =
-                                    await getBoardSchema(context);
+                                try {
+                                    context.agentContext.crossWordState =
+                                        await getBoardSchema(context);
 
-                                sendSiteTranslatorStatus(
-                                    targetTranslator,
-                                    "initialized",
-                                    context,
-                                );
+                                    browserControls.setAgentStatus(
+                                        false,
+                                        `Finished initializing ${targetTranslator}`,
+                                    );
+                                } catch (e) {
+                                    browserControls.setAgentStatus(
+                                        false,
+                                        `Failed to initialize ${targetTranslator}`,
+                                    );
+                                }
 
                                 if (context.agentContext.crossWordState) {
                                     context.notify(
@@ -688,28 +695,6 @@ async function executeBrowserAction(
     return undefined;
 }
 
-function sendSiteTranslatorStatus(
-    schemaName: string,
-    status: string,
-    context: SessionContext<BrowserActionContext>,
-) {
-    const webSocketEndpoint = context.agentContext.webSocket;
-    const callId = new Date().getTime().toString();
-
-    if (webSocketEndpoint) {
-        webSocketEndpoint.send(
-            JSON.stringify({
-                method: "browser/siteTranslatorStatus",
-                id: callId,
-                params: {
-                    translator: schemaName,
-                    status: status,
-                },
-            }),
-        );
-    }
-}
-
 async function handleTabIndexActions(
     action: any,
     context: SessionContext<BrowserActionContext>,

diff --git a/ts/packages/agents/browser/src/agent/interface.mts b/ts/packages/agents/browser/src/agent/interface.mts
@@ -18,6 +18,8 @@ export interface BrowserControl {
     reload(): Promise<void>;
 
     getPageUrl(): Promise<string>;
+
+    setAgentStatus(isBusy: boolean, message: string): void;
 }
 
 export type BrowserControlInvokeFunctions = {
@@ -28,3 +30,7 @@ export type BrowserControlInvokeFunctions = {
     reload(): Promise<void>;
     getPageUrl(): Promise<string>;
 };
+
+export type BrowserControlCallFunctions = {
+    setAgentStatus(params: { isBusy: boolean; message: string }): void;
+};
diff --git a/ts/packages/agents/browser/src/agent/rpc/externalBrowserControlClient.mts b/ts/packages/agents/browser/src/agent/rpc/externalBrowserControlClient.mts
@@ -4,6 +4,7 @@
 import { WebSocket } from "ws";
 import {
     BrowserControl,
+    BrowserControlCallFunctions,
     BrowserControlInvokeFunctions,
 } from "../interface.mjs";
 import { createGenericChannel } from "agent-rpc/channel";
@@ -40,9 +41,10 @@ export function createExternalBrowserClient(
         browserControlChannel.disconnect();
     });
 
-    const rpc = createRpc<BrowserControlInvokeFunctions>(
-        browserControlChannel.channel,
-    );
+    const rpc = createRpc<
+        BrowserControlInvokeFunctions,
+        BrowserControlCallFunctions
+    >("browser:extension", browserControlChannel.channel);
 
     return {
         openWebPage: async (url: string) => {
@@ -63,5 +65,11 @@ export function createExternalBrowserClient(
         getPageUrl: async () => {
             return rpc.invoke("getPageUrl", undefined);
         },
+        setAgentStatus: (isBusy: boolean, message: string) => {
+            rpc.send("setAgentStatus", {
+                isBusy,
+                message,
+            });
+        },
     };
 }
diff --git a/ts/packages/agents/browser/src/agent/webTypeAgent.mts b/ts/packages/agents/browser/src/agent/webTypeAgent.mts
@@ -127,7 +127,7 @@ function ensureWebAgentChannels(context: SessionContext<BrowserActionContext>) {
         );
     });
 
-    createRpc(registerChannel.channel, {
+    createRpc("webagent", registerChannel.channel, {
         addTypeAgent: async (param: {
             name: string;
             manifest: AppAgentManifest;

diff --git a/ts/packages/agents/browser/src/extension/serviceWorker/externalBrowserControlServer.ts b/ts/packages/agents/browser/src/extension/serviceWorker/externalBrowserControlServer.ts
@@ -4,9 +4,13 @@
 import { RpcChannel } from "agent-rpc/channel";
 import { getActiveTab } from "./tabManager";
 import { createRpc } from "agent-rpc/rpc";
-import { BrowserControlInvokeFunctions } from "../../agent/interface.mjs";
+import {
+    BrowserControlCallFunctions,
+    BrowserControlInvokeFunctions,
+} from "../../agent/interface.mjs";
+import { showBadgeBusy, showBadgeHealthy } from "./ui";
 export function createExternalBrowserServer(channel: RpcChannel) {
-    const browserControlInvokeFunctions: BrowserControlInvokeFunctions = {
+    const invokeFunctions: BrowserControlInvokeFunctions = {
         openWebPage: async (url: string) => {
             const targetTab = await getActiveTab();
             if (targetTab) {
@@ -51,5 +55,15 @@ export function createExternalBrowserServer(channel: RpcChannel) {
             }
         },
     };
-    return createRpc(channel, browserControlInvokeFunctions);
+    const callFunctions: BrowserControlCallFunctions = {
+        setAgentStatus: ({ isBusy, message }) => {
+            if (isBusy) {
+                showBadgeBusy();
+            } else {
+                showBadgeHealthy();
+            }
+            console.log(`${message} (isBusy: ${isBusy})`);
+        },
+    };
+    return createRpc(channel, invokeFunctions, callFunctions);
 }
diff --git a/ts/packages/agents/browser/src/extension/serviceWorker/websocket.ts b/ts/packages/agents/browser/src/extension/serviceWorker/websocket.ts
@@ -104,31 +104,17 @@ export async function ensureWebsocketConnected(): Promise<
                 const [schema, actionName] = data.method?.split("/");
 
                 if (schema == "browser") {
-                    if (actionName == "siteTranslatorStatus") {
-                        if (data.params.status == "initializing") {
-                            showBadgeBusy();
-                            console.log(
-                                `Initializing ${data.params.translator}`,
-                            );
-                        } else if (data.params.status == "initialized") {
-                            showBadgeHealthy();
-                            console.log(
-                                `Finished initializing ${data.params.translator}`,
-                            );
-                        }
-                    } else {
-                        const response = await runBrowserAction({
-                            actionName: actionName,
-                            parameters: data.params,
-                        });
-
-                        webSocket?.send(
-                            JSON.stringify({
-                                id: data.id,
-                                result: response,
-                            }),
-                        );
-                    }
+                    const response = await runBrowserAction({
+                        actionName: actionName,
+                        parameters: data.params,
+                    });
+
+                    webSocket?.send(
+                        JSON.stringify({
+                            id: data.id,
+                            result: response,
+                        }),
+                    );
                 }
             }
         };

diff --git a/ts/packages/dispatcher/src/rpc/clientIOClient.ts b/ts/packages/dispatcher/src/rpc/clientIOClient.ts
@@ -17,6 +17,7 @@ import { DisplayAppendMode, TypeAgentAction } from "@typeagent/agent-sdk";
 
 export function createClientIORpcClient(channel: RpcChannel): ClientIO {
     const rpc = createRpc<ClientIOInvokeFunctions, ClientIOCallFunctions>(
+        "clientio",
         channel,
     );
     return {

diff --git a/ts/packages/dispatcher/src/rpc/clientIOServer.ts b/ts/packages/dispatcher/src/rpc/clientIOServer.ts
@@ -77,5 +77,10 @@ export function createClientIORpcServer(
             ),
         takeAction: (params) => clientIO.takeAction(params.action, params.data),
     };
-    createRpc(channel, clientIOInvokeFunctions, clientIOCallFunctions);
+    createRpc(
+        "clientio",
+        channel,
+        clientIOInvokeFunctions,
+        clientIOCallFunctions,
+    );
 }
diff --git a/ts/packages/dispatcher/src/rpc/dispatcherClient.ts b/ts/packages/dispatcher/src/rpc/dispatcherClient.ts
@@ -11,7 +11,7 @@ function remoteCallNotSupported(): never {
 }
 
 export function createDispatcherRpcClient(channel: RpcChannel): Dispatcher {
-    const rpc = createRpc<DispatcherInvokeFunctions>(channel);
+    const rpc = createRpc<DispatcherInvokeFunctions>("dispatcher", channel);
 
     return {
         async processCommand(command, requestId, attachments) {

diff --git a/ts/packages/dispatcher/src/rpc/dispatcherServer.ts b/ts/packages/dispatcher/src/rpc/dispatcherServer.ts
@@ -48,5 +48,5 @@ export function createDispatcherRpcServer(
         },
     };
 
-    createRpc(channel, dispatcherInvokeHandler);
+    createRpc("dispatcher", channel, dispatcherInvokeHandler);
 }
diff --git a/ts/packages/shell/src/main/inlineBrowserControl.ts b/ts/packages/shell/src/main/inlineBrowserControl.ts
@@ -37,5 +37,8 @@ export function createInlineBrowserControl(
         async getPageUrl() {
             return shellWindow.inlineBrowser.webContents.getURL();
         },
+        setAgentStatus(isBusy: boolean, message: string) {
+            console.log(`${message} (isBusy: ${isBusy})`);
+        },
     };
 }
diff --git a/ts/packages/shell/src/preload/webView.ts b/ts/packages/shell/src/preload/webView.ts
@@ -19,25 +19,15 @@ ipcRenderer.on("received-from-browser-ipc", async (_, data) => {
         const [schema, actionName] = data.method?.split("/");
 
         if (schema === "browser") {
-            if (actionName == "siteTranslatorStatus") {
-                if (data.body.status == "initializing") {
-                    console.log(`Initializing ${data.body.translator}`);
-                } else if (data.body.status == "initialized") {
-                    console.log(
-                        `Finished initializing ${data.body.translator}`,
-                    );
-                }
-            } else {
-                const response = await runBrowserAction({
-                    actionName: actionName,
-                    parameters: data.params,
-                });
+            const response = await runBrowserAction({
+                actionName: actionName,
+                parameters: data.params,
+            });
 
-                sendToBrowserAgent({
-                    id: data.id,
-                    result: response,
-                });
-            }
+            sendToBrowserAgent({
+                id: data.id,
+                result: response,
+            });
         } else if (schema.startsWith("browser.")) {
             const message = await runSiteAction(schema, {
                 actionName: actionName,
-Original file line number
+Diff line change
@@ Expand Up / @@ -48,5 +48,5 @@ export function createDispatcherRpcServer( @@
             },
         };
-        createRpc(channel, dispatcherInvokeHandler);
+        createRpc("dispatcher", channel, dispatcherInvokeHandler);
     }