@memo-code/memo 0.8.8 → 0.8.10

package/README.md

@@ -84,6 +84,7 @@ memo web --host 127.0.0.1 --port 5494 --open
 - Sidebar includes dedicated entries for `MCP Servers` and `Skills`:
     - MCP: create/edit/remove/login/logout and active toggles.
     - Skills: create/delete, detail preview, and active toggles.
+- Web chat input panel shows live context usage percentage.
 
 ## Configuration
 

package/dist/web/server/main.cjs

@@ -142776,6 +142776,7 @@ var require_chat_service = __commonJS({
     var stream_service_1 = require_stream_service();
     var workspaces_service_1 = require_workspaces_service();
     var MAX_LIVE_SESSIONS = 20;
+    var MAX_QUEUED_INPUTS = 3;
     function normalizeMode(value) {
       if (value === "none" || value === "once" || value === "full")
         return value;
@@ -142847,6 +142848,7 @@ var require_chat_service = __commonJS({
         await this.workspacesService.touchLastUsed(workspace.id);
         const config = await this.memoConfigService.load();
         const provider = this.selectProvider(config.providers, input.providerName, config.current_provider);
+        const contextWindow = (0, core_1.resolveContextWindowForProvider)(config, provider);
         const sessionId = (0, node_crypto_1.randomUUID)();
         const runtime = await this.createRuntime({
           id: sessionId,
@@ -142858,7 +142860,8 @@ var require_chat_service = __commonJS({
           cwd: workspace.cwd,
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           activeMcpServers: input.activeMcpServers && input.activeMcpServers.length > 0 ? input.activeMcpServers : config.active_mcp_servers,
-          toolPermissionMode: normalizeMode(input.toolPermissionMode)
+          toolPermissionMode: normalizeMode(input.toolPermissionMode),
+          contextWindow
         });
         this.sessions.set(runtime.id, runtime);
         this.touchSession(runtime);
@@ -142878,6 +142881,7 @@ var require_chat_service = __commonJS({
         await this.workspacesService.touchLastUsed(workspace.id);
         const config = await this.memoConfigService.load();
         const provider = this.selectProvider(config.providers, void 0, config.current_provider);
+        const contextWindow = (0, core_1.resolveContextWindowForProvider)(config, provider);
         const historyMessages = [];
         const turns = [];
         for (const turn of detail.turns) {
@@ -142910,7 +142914,8 @@ var require_chat_service = __commonJS({
           startedAt: detail.date.startedAt,
           activeMcpServers: config.active_mcp_servers,
           toolPermissionMode: "once",
-          historyFilePath: detail.filePath
+          historyFilePath: detail.filePath,
+          contextWindow
         });
         const system = runtime.agentSession.history[0];
         runtime.agentSession.history = system ? [system, ...historyMessages] : [...historyMessages];
@@ -143033,23 +143038,70 @@ var require_chat_service = __commonJS({
       }
       async submitInput(sessionId, input) {
         const session = this.requireSession(sessionId);
+        const trimmed = input.trim();
+        if (!trimmed) {
+          throw new common_1.BadRequestException("input is required");
+        }
         if (session.status === "running") {
+          if (session.queuedInputs.length >= MAX_QUEUED_INPUTS) {
+            return {
+              accepted: false,
+              kind: "turn",
+              status: "error",
+              message: `Queue is full (max ${MAX_QUEUED_INPUTS}).`
+            };
+          }
+          session.queuedInputs.push({
+            id: (0, node_crypto_1.randomUUID)(),
+            input: trimmed,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          this.touchSession(session);
+          this.streamService.broadcast(session.id, {
+            type: "session.snapshot",
+            payload: this.toState(session)
+          });
           return {
-            accepted: false,
+            accepted: true,
             kind: "turn",
-            status: "error",
-            message: "Session is busy."
+            status: "ok"
           };
         }
-        const trimmed = input.trim();
-        if (!trimmed) {
-          throw new common_1.BadRequestException("input is required");
-        }
         if (trimmed.startsWith("/")) {
           return this.runSlashCommand(session, trimmed);
         }
         return this.runCoreTurn(session, trimmed, trimmed);
       }
+      removeQueuedInput(sessionId, queueId) {
+        const session = this.requireSession(sessionId);
+        const targetQueueId = queueId.trim();
+        if (!targetQueueId) {
+          throw new common_1.BadRequestException("queueId is required");
+        }
+        const next = session.queuedInputs.filter((item) => item.id !== targetQueueId);
+        if (next.length === session.queuedInputs.length) {
+          return { removed: false };
+        }
+        session.queuedInputs = next;
+        this.touchSession(session);
+        this.streamService.broadcast(session.id, {
+          type: "session.snapshot",
+          payload: this.toState(session)
+        });
+        return { removed: true };
+      }
+      sendQueuedInputNow(sessionId) {
+        const session = this.requireSession(sessionId);
+        if (session.queuedInputs.length === 0) {
+          return { triggered: false };
+        }
+        if (session.status === "running") {
+          this.cancelCurrentTurn(sessionId);
+          return { triggered: true };
+        }
+        void this.drainQueuedInputs(session);
+        return { triggered: true };
+      }
       cancelCurrentTurn(sessionId) {
         const session = this.requireSession(sessionId);
         if (session.status === "running") {
@@ -143061,6 +143113,12 @@ var require_chat_service = __commonJS({
       async compactSession(sessionId) {
         const session = this.requireSession(sessionId);
         const result = await session.agentSession.compactHistory("manual");
+        session.currentContextTokens = Math.max(0, result.afterTokens);
+        this.touchSession(session);
+        this.streamService.broadcast(session.id, {
+          type: "session.snapshot",
+          payload: this.toState(session)
+        });
         this.streamService.broadcast(session.id, {
           type: "system.message",
           payload: {
@@ -143119,6 +143177,10 @@ var require_chat_service = __commonJS({
             title: "New Session",
             resetTurns: true
           });
+          this.streamService.broadcast(session.id, {
+            type: "session.snapshot",
+            payload: this.toState(session)
+          });
           this.sendSystemMessage(session, "New Session", "Started a fresh session.");
           return { accepted: true, kind: "command", status: "ok" };
         }
@@ -143206,9 +143268,41 @@ var require_chat_service = __commonJS({
           };
         }
       }
+      async drainQueuedInputs(session) {
+        if (session.status !== "idle")
+          return;
+        if (session.queueDraining)
+          return;
+        if (session.queuedInputs.length === 0)
+          return;
+        session.queueDraining = true;
+        try {
+          while (session.status === "idle" && session.queuedInputs.length > 0) {
+            const next = session.queuedInputs.shift();
+            if (!next)
+              break;
+            this.touchSession(session);
+            this.streamService.broadcast(session.id, {
+              type: "session.snapshot",
+              payload: this.toState(session)
+            });
+            const input = next.input.trim();
+            if (!input)
+              continue;
+            if (input.startsWith("/")) {
+              await this.runSlashCommand(session, input);
+            } else {
+              await this.runCoreTurn(session, input, input);
+            }
+          }
+        } finally {
+          session.queueDraining = false;
+        }
+      }
       async recreateSessionRuntime(session, options) {
         this.resolvePendingApprovals(session, "deny");
         await session.agentSession.close();
+        const config = await this.memoConfigService.load();
         if (options.providerName)
           session.providerName = options.providerName;
         if (options.model)
@@ -143222,6 +143316,11 @@ var require_chat_service = __commonJS({
         if (options.title) {
           session.title = options.title;
         }
+        session.contextWindow = (0, core_1.resolveContextWindowForProvider)(config, {
+          name: session.providerName,
+          model: session.model
+        });
+        session.currentContextTokens = 0;
         if (options.resetTurns) {
           session.turn = 0;
           session.turns = [];
@@ -143275,6 +143374,10 @@ var require_chat_service = __commonJS({
           historyFilePath: input.historyFilePath,
           turns: [],
           pendingApprovals: /* @__PURE__ */ new Map(),
+          currentContextTokens: 0,
+          contextWindow: input.contextWindow,
+          queuedInputs: [],
+          queueDraining: false,
           agentSession: null
         };
         runtime.agentSession = await this.createCoreSession(runtime);
@@ -143325,10 +143428,11 @@ var require_chat_service = __commonJS({
             });
           },
           hooks: {
-            onTurnStart: ({ turn, input }) => {
+            onTurnStart: ({ turn, input, promptTokens }) => {
               runtime.status = "running";
               runtime.activeTurn = turn;
               runtime.turn = Math.max(runtime.turn, turn);
+              runtime.currentContextTokens = typeof promptTokens === "number" && Number.isFinite(promptTokens) ? Math.max(0, promptTokens) : runtime.currentContextTokens;
               const displayInput = runtime.nextInputDisplay ?? input;
               runtime.nextInputDisplay = void 0;
               const record = this.getOrCreateTurnRecord(runtime, turn);
@@ -143350,7 +143454,24 @@ var require_chat_service = __commonJS({
                 type: "turn.start",
                 payload: {
                   turn,
-                  input: displayInput
+                  input: displayInput,
+                  promptTokens
+                }
+              });
+            },
+            onContextUsage: ({ turn, step, phase, promptTokens, contextWindow, thresholdTokens, usagePercent }) => {
+              runtime.currentContextTokens = Math.max(0, promptTokens);
+              runtime.contextWindow = Math.max(0, contextWindow);
+              this.streamService.broadcast(runtime.id, {
+                type: "context.usage",
+                payload: {
+                  turn,
+                  step,
+                  phase,
+                  promptTokens,
+                  contextWindow,
+                  thresholdTokens,
+                  usagePercent
                 }
               });
             },
@@ -143416,6 +143537,7 @@ var require_chat_service = __commonJS({
                 type: "session.snapshot",
                 payload: this.toState(runtime)
               });
+              void this.drainQueuedInputs(runtime);
             },
             onTitleGenerated: ({ title }) => {
               runtime.title = title;
@@ -143442,6 +143564,7 @@ var require_chat_service = __commonJS({
           sessionId: runtime.id,
           mode: "interactive",
           providerName: runtime.providerName,
+          contextWindow: runtime.contextWindow,
           activeMcpServers: runtime.activeMcpServers,
           toolPermissionMode: runtime.toolPermissionMode,
           dangerous: runtime.toolPermissionMode === "full",
@@ -143516,7 +143639,10 @@ var require_chat_service = __commonJS({
             params: session.pendingApproval.params
           } : void 0,
           activeMcpServers: session.activeMcpServers,
-          toolPermissionMode: session.toolPermissionMode
+          toolPermissionMode: session.toolPermissionMode,
+          queuedInputs: session.queuedInputs.map((item) => ({ ...item })),
+          currentContextTokens: session.currentContextTokens,
+          contextWindow: session.contextWindow
         };
       }
       toSnapshot(session) {
@@ -144363,6 +144489,8 @@ var require_rpc_router_service = __commonJS({
     var workspaces_service_1 = require_workspaces_service();
     var session_runtime_registry_service_1 = require_session_runtime_registry_service();
     var ws_errors_1 = require_ws_errors();
+    var TOOL_PERMISSION_MODES = ["none", "once", "full"];
+    var APPROVAL_DECISIONS = ["once", "session", "deny"];
     function asObject(input) {
       if (!input || typeof input !== "object" || Array.isArray(input)) {
         return {};
@@ -144382,6 +144510,32 @@ var require_rpc_router_service = __commonJS({
       const trimmed = value.trim();
       return trimmed.length > 0 ? trimmed : void 0;
     }
+    function asFiniteNumber(value) {
+      return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+    }
+    function asStringArray(value) {
+      if (!Array.isArray(value))
+        return void 0;
+      return value.filter((item) => typeof item === "string");
+    }
+    function requireTrimmedStringArray(input, key) {
+      if (!Array.isArray(input[key])) {
+        throw new ws_errors_1.WsRpcError("BAD_REQUEST", `${key} must be string[]`);
+      }
+      return input[key].filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+    }
+    function asEnum(value, allowed) {
+      if (typeof value !== "string")
+        return void 0;
+      return allowed.includes(value) ? value : void 0;
+    }
+    function requireEnum(value, allowed, message) {
+      const parsed = asEnum(value, allowed);
+      if (!parsed) {
+        throw new ws_errors_1.WsRpcError("BAD_REQUEST", message);
+      }
+      return parsed;
+    }
     var RpcRouterService = class RpcRouterService {
       sessionsService;
       chatService;
@@ -144389,6 +144543,7 @@ var require_rpc_router_service = __commonJS({
       skillsService;
       workspacesService;
       sessionRegistry;
+      handlers;
       constructor(sessionsService, chatService, mcpService, skillsService, workspacesService, sessionRegistry) {
         this.sessionsService = sessionsService;
         this.chatService = chatService;
@@ -144396,199 +144551,140 @@ var require_rpc_router_service = __commonJS({
         this.skillsService = skillsService;
         this.workspacesService = workspacesService;
         this.sessionRegistry = sessionRegistry;
+        this.handlers = {
+          ...this.buildSessionHandlers(),
+          ...this.buildChatHandlers(),
+          ...this.buildMcpHandlers(),
+          ...this.buildSkillHandlers(),
+          ...this.buildWorkspaceHandlers()
+        };
       }
       async dispatch(context, method, params) {
-        const input = asObject(params);
-        if (method === "sessions.list") {
-          return this.sessionsService.list(input);
-        }
-        if (method === "sessions.detail") {
-          const sessionId = requireString(input, "sessionId");
-          return this.sessionsService.getSessionDetail(sessionId);
-        }
-        if (method === "sessions.events") {
-          const sessionId = requireString(input, "sessionId");
-          return this.sessionsService.getSessionEvents(sessionId, input);
-        }
-        if (method === "sessions.remove") {
-          const sessionId = requireString(input, "sessionId");
-          return this.chatService.deleteSession(sessionId);
+        const handler = this.handlers[method];
+        if (!handler) {
+          throw new ws_errors_1.WsRpcError("METHOD_NOT_FOUND", `Unknown method: ${method}`);
         }
-        if (method === "chat.session.create") {
-          const mode = input.toolPermissionMode;
-          return this.chatService.createSession({
+        return handler(context, asObject(params));
+      }
+      buildSessionHandlers() {
+        return {
+          "sessions.list": (_context, input) => this.sessionsService.list(input),
+          "sessions.detail": (_context, input) => this.sessionsService.getSessionDetail(requireString(input, "sessionId")),
+          "sessions.events": (_context, input) => this.sessionsService.getSessionEvents(requireString(input, "sessionId"), input),
+          "sessions.remove": (_context, input) => this.chatService.deleteSession(requireString(input, "sessionId"))
+        };
+      }
+      buildChatHandlers() {
+        return {
+          "chat.session.create": (_context, input) => this.chatService.createSession({
             providerName: asString(input.providerName),
             workspaceId: asString(input.workspaceId),
             cwd: asString(input.cwd),
-            toolPermissionMode: mode === "none" || mode === "once" || mode === "full" ? mode : void 0,
-            activeMcpServers: Array.isArray(input.activeMcpServers) ? input.activeMcpServers.filter((item) => typeof item === "string") : void 0
-          });
-        }
-        if (method === "chat.providers.list") {
-          return this.chatService.listProviders();
-        }
-        if (method === "chat.runtimes.list") {
-          return this.chatService.listRuntimeBadges({
+            toolPermissionMode: asEnum(input.toolPermissionMode, TOOL_PERMISSION_MODES),
+            activeMcpServers: asStringArray(input.activeMcpServers)
+          }),
+          "chat.providers.list": () => this.chatService.listProviders(),
+          "chat.runtimes.list": (_context, input) => this.chatService.listRuntimeBadges({
             workspaceId: asString(input.workspaceId)
-          });
-        }
-        if (method === "chat.session.state") {
-          const sessionId = requireString(input, "sessionId");
-          this.sessionRegistry.requireOwner(sessionId, context.connectionId);
-          return this.chatService.getSessionState(sessionId);
-        }
-        if (method === "chat.session.attach") {
-          const sessionId = requireString(input, "sessionId");
-          this.sessionRegistry.claim(sessionId, context.connectionId);
-          try {
-            return await this.chatService.attachSession(sessionId);
-          } catch (error) {
+          }),
+          "chat.session.state": (context, input) => this.chatService.getSessionState(this.requireOwnedSession(input, context)),
+          "chat.session.attach": async (context, input) => {
+            const sessionId = requireString(input, "sessionId");
+            this.sessionRegistry.claim(sessionId, context.connectionId);
+            try {
+              return await this.chatService.attachSession(sessionId);
+            } catch (error) {
+              this.sessionRegistry.release(sessionId, context.connectionId);
+              throw error;
+            }
+          },
+          "chat.session.close": (context, input) => {
+            const sessionId = this.requireOwnedSession(input, context);
+            const result = this.chatService.closeSession(sessionId);
             this.sessionRegistry.release(sessionId, context.connectionId);
-            throw error;
-          }
-        }
-        if (method === "chat.session.close") {
-          const sessionId = requireString(input, "sessionId");
-          this.sessionRegistry.requireOwner(sessionId, context.connectionId);
-          const result = this.chatService.closeSession(sessionId);
-          this.sessionRegistry.release(sessionId, context.connectionId);
-          return result;
-        }
-        if (method === "chat.files.suggest") {
-          const sessionId = asString(input.sessionId);
-          if (sessionId) {
-            this.sessionRegistry.requireOwner(sessionId, context.connectionId);
-          }
-          const query = typeof input.query === "string" ? input.query : "";
-          const limit = typeof input.limit === "number" && Number.isFinite(input.limit) ? input.limit : void 0;
-          return this.chatService.suggestFiles({
-            query,
-            limit,
-            sessionId,
-            workspaceId: asString(input.workspaceId)
-          });
-        }
-        if (method === "chat.input.submit") {
-          const sessionId = requireString(input, "sessionId");
-          const text = requireString(input, "input");
-          this.sessionRegistry.requireOwner(sessionId, context.connectionId);
-          return this.chatService.submitInput(sessionId, text);
-        }
-        if (method === "chat.turn.cancel") {
-          const sessionId = requireString(input, "sessionId");
-          this.sessionRegistry.requireOwner(sessionId, context.connectionId);
-          return this.chatService.cancelCurrentTurn(sessionId);
-        }
-        if (method === "chat.session.compact") {
-          const sessionId = requireString(input, "sessionId");
-          this.sessionRegistry.requireOwner(sessionId, context.connectionId);
-          return this.chatService.compactSession(sessionId);
-        }
-        if (method === "chat.approval.respond") {
-          const sessionId = requireString(input, "sessionId");
-          const fingerprint = requireString(input, "fingerprint");
-          const decision = input.decision;
-          if (decision !== "once" && decision !== "session" && decision !== "deny") {
-            throw new ws_errors_1.WsRpcError("BAD_REQUEST", "decision must be once | session | deny");
-          }
-          this.sessionRegistry.requireOwner(sessionId, context.connectionId);
-          return this.chatService.applyApprovalDecision(sessionId, fingerprint, decision);
-        }
-        if (method === "mcp.servers.list") {
-          return this.mcpService.list();
-        }
-        if (method === "mcp.servers.get") {
-          return this.mcpService.get(requireString(input, "name"));
-        }
-        if (method === "mcp.servers.create") {
-          const name = requireString(input, "name");
-          return this.mcpService.create(name, input.config);
-        }
-        if (method === "mcp.servers.update") {
-          const name = requireString(input, "name");
-          return this.mcpService.update(name, input.config);
-        }
-        if (method === "mcp.servers.remove") {
-          return this.mcpService.remove(requireString(input, "name"));
-        }
-        if (method === "mcp.servers.login") {
-          const name = requireString(input, "name");
-          const scopes = Array.isArray(input.scopes) ? input.scopes.filter((item) => typeof item === "string") : void 0;
-          return this.mcpService.login(name, scopes);
-        }
-        if (method === "mcp.servers.logout") {
-          return this.mcpService.logout(requireString(input, "name"));
-        }
-        if (method === "mcp.active.set") {
-          if (!Array.isArray(input.names)) {
-            throw new ws_errors_1.WsRpcError("BAD_REQUEST", "names must be string[]");
-          }
-          const names = input.names.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
-          return this.mcpService.setActive(names);
-        }
-        if (method === "skills.list") {
-          return this.skillsService.list({
+            return result;
+          },
+          "chat.files.suggest": (context, input) => {
+            const sessionId = asString(input.sessionId);
+            if (sessionId) {
+              this.sessionRegistry.requireOwner(sessionId, context.connectionId);
+            }
+            return this.chatService.suggestFiles({
+              query: typeof input.query === "string" ? input.query : "",
+              limit: asFiniteNumber(input.limit),
+              sessionId,
+              workspaceId: asString(input.workspaceId)
+            });
+          },
+          "chat.input.submit": (context, input) => this.chatService.submitInput(this.requireOwnedSession(input, context), requireString(input, "input")),
+          "chat.queue.remove": (context, input) => this.chatService.removeQueuedInput(this.requireOwnedSession(input, context), requireString(input, "queueId")),
+          "chat.queue.send_now": (context, input) => this.chatService.sendQueuedInputNow(this.requireOwnedSession(input, context)),
+          "chat.turn.cancel": (context, input) => this.chatService.cancelCurrentTurn(this.requireOwnedSession(input, context)),
+          "chat.session.compact": (context, input) => this.chatService.compactSession(this.requireOwnedSession(input, context)),
+          "chat.approval.respond": (context, input) => this.chatService.applyApprovalDecision(this.requireOwnedSession(input, context), requireString(input, "fingerprint"), requireEnum(input.decision, APPROVAL_DECISIONS, "decision must be once | session | deny"))
+        };
+      }
+      buildMcpHandlers() {
+        return {
+          "mcp.servers.list": () => this.mcpService.list(),
+          "mcp.servers.get": (_context, input) => this.mcpService.get(requireString(input, "name")),
+          "mcp.servers.create": (_context, input) => this.mcpService.create(requireString(input, "name"), input.config),
+          "mcp.servers.update": (_context, input) => this.mcpService.update(requireString(input, "name"), input.config),
+          "mcp.servers.remove": (_context, input) => this.mcpService.remove(requireString(input, "name")),
+          "mcp.servers.login": (_context, input) => this.mcpService.login(requireString(input, "name"), asStringArray(input.scopes)),
+          "mcp.servers.logout": (_context, input) => this.mcpService.logout(requireString(input, "name")),
+          "mcp.active.set": (_context, input) => this.mcpService.setActive(requireTrimmedStringArray(input, "names"))
+        };
+      }
+      buildSkillHandlers() {
+        return {
+          "skills.list": (_context, input) => this.skillsService.list({
             scope: input.scope,
             q: input.q,
             workspaceId: input.workspaceId
-          });
-        }
-        if (method === "skills.get") {
-          return this.skillsService.get(requireString(input, "id"));
-        }
-        if (method === "skills.create") {
-          return this.skillsService.create({
+          }),
+          "skills.get": (_context, input) => this.skillsService.get(requireString(input, "id")),
+          "skills.create": (_context, input) => this.skillsService.create({
             scope: input.scope,
             name: input.name,
             description: input.description,
             content: input.content,
             workspaceId: input.workspaceId
-          });
-        }
-        if (method === "skills.update") {
-          return this.skillsService.update(requireString(input, "id"), {
+          }),
+          "skills.update": (_context, input) => this.skillsService.update(requireString(input, "id"), {
             description: input.description,
             content: input.content
-          });
-        }
-        if (method === "skills.remove") {
-          return this.skillsService.remove(requireString(input, "id"));
-        }
-        if (method === "skills.active.set") {
-          if (!Array.isArray(input.ids)) {
-            throw new ws_errors_1.WsRpcError("BAD_REQUEST", "ids must be string[]");
-          }
-          const ids = input.ids.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
-          return this.skillsService.setActive(ids);
-        }
-        if (method === "workspace.list") {
-          return this.workspacesService.list();
-        }
-        if (method === "workspace.add") {
-          return this.workspacesService.add({
+          }),
+          "skills.remove": (_context, input) => this.skillsService.remove(requireString(input, "id")),
+          "skills.active.set": (_context, input) => this.skillsService.setActive(requireTrimmedStringArray(input, "ids"))
+        };
+      }
+      buildWorkspaceHandlers() {
+        return {
+          "workspace.list": () => this.workspacesService.list(),
+          "workspace.add": (_context, input) => this.workspacesService.add({
             cwd: input.cwd,
             name: input.name
-          });
-        }
-        if (method === "workspace.update") {
-          return this.workspacesService.update(requireString(input, "workspaceId"), {
+          }),
+          "workspace.update": (_context, input) => this.workspacesService.update(requireString(input, "workspaceId"), {
             name: input.name
-          });
-        }
-        if (method === "workspace.remove") {
-          const workspaceId = requireString(input, "workspaceId");
-          const sessionsResult = await this.sessionsService.removeSessionsByWorkspace(workspaceId);
-          const workspaceResult = await this.workspacesService.remove(workspaceId);
-          return {
-            ...workspaceResult,
-            deletedSessions: sessionsResult.deletedSessions
-          };
-        }
-        if (method === "workspace.fs.list") {
-          const path = asString(input.path);
-          return this.workspacesService.listDirectories(path);
-        }
-        throw new ws_errors_1.WsRpcError("METHOD_NOT_FOUND", `Unknown method: ${method}`);
+          }),
+          "workspace.remove": async (_context, input) => {
+            const workspaceId = requireString(input, "workspaceId");
+            const sessionsResult = await this.sessionsService.removeSessionsByWorkspace(workspaceId);
+            const workspaceResult = await this.workspacesService.remove(workspaceId);
+            return {
+              ...workspaceResult,
+              deletedSessions: sessionsResult.deletedSessions
+            };
+          },
+          "workspace.fs.list": (_context, input) => this.workspacesService.listDirectories(asString(input.path))
+        };
+      }
+      requireOwnedSession(input, context) {
+        const sessionId = requireString(input, "sessionId");
+        this.sessionRegistry.requireOwner(sessionId, context.connectionId);
+        return sessionId;
       }
     };
     exports2.RpcRouterService = RpcRouterService;
@@ -144952,6 +145048,12 @@ var require_ws_gateway_service = __commonJS({
             data: { sessionId, ...frame.payload }
           };
         }
+        if (frame.type === "context.usage") {
+          return {
+            topic: "chat.context.usage",
+            data: { sessionId, ...frame.payload }
+          };
+        }
         if (frame.type === "turn.final") {
           return {
             topic: "chat.turn.final",