@decocms/mesh-sdk 1.2.2 → 1.2.3

package/src/lib/default-model.ts

@@ -1,4 +1,8 @@
-import type { AiProviderModel, ProviderId } from "../types/ai-providers";
+import type {
+  AiProviderModel,
+  AiProviderKey,
+  ProviderId,
+} from "../types/ai-providers";
 
 /**
  * Preferred default models for each well-known provider.
@@ -11,8 +15,7 @@ export const DEFAULT_MODEL_PREFERENCES: Partial<Record<ProviderId, string[]>> =
   {
     anthropic: ["claude-sonnet-4-6", "claude-sonnet", "claude"],
     openrouter: [
-      "anthropic/claude-opus-4.6",
-      "anthropic/claude-4.6-opus",
+      "anthropic/claude-opus-4.8",
       "anthropic/claude-sonnet-4-6",
       "anthropic/claude-sonnet",
       "anthropic/claude",
@@ -28,6 +31,7 @@ export const DEFAULT_MODEL_PREFERENCES: Partial<Record<ProviderId, string[]>> =
       "claude-code:opus",
       "claude-code:haiku",
     ],
+    codex: ["codex:gpt-5.4"],
   };
 
 /**
@@ -44,6 +48,8 @@ export const FAST_MODEL_PREFERENCES: Partial<Record<ProviderId, string[]>> = {
   ],
   deco: ["qwen/qwen3.5-flash", "anthropic/claude-haiku"],
   google: ["gemini-2.5-flash", "gemini-3-flash"],
+  "claude-code": ["claude-code:haiku", "claude-code:sonnet"],
+  codex: ["codex:gpt-5.4-mini"],
 };
 
 /**
@@ -55,6 +61,185 @@ export function getFastModel(providerId: ProviderId): string | null {
   return candidates?.[0] ?? null;
 }
 
+/**
+ * Preferred smart (balanced) models per provider — used as the "Smart" tier
+ * in Simple Model Mode.
+ */
+export const SMART_MODEL_PREFERENCES: Partial<Record<ProviderId, string[]>> = {
+  anthropic: ["claude-sonnet-4-6", "claude-sonnet"],
+  openrouter: [
+    "anthropic/claude-sonnet-4.6",
+    "anthropic/claude-sonnet",
+    "anthropic/claude-opus-4.8",
+    "google/gemini-3-pro",
+  ],
+  deco: [
+    "anthropic/claude-sonnet-4.6",
+    "anthropic/claude-sonnet",
+    "anthropic/claude",
+  ],
+  google: ["gemini-3-pro", "gemini-3-flash"],
+  "claude-code": ["claude-code:sonnet"],
+  codex: ["codex:gpt-5.4"],
+};
+
+/**
+ * Preferred thinking/reasoning models per provider — used as the "Thinking" tier
+ * in Simple Model Mode.
+ */
+export const THINKING_MODEL_PREFERENCES: Partial<Record<ProviderId, string[]>> =
+  {
+    anthropic: ["claude-opus-4-8", "claude-sonnet-4-6", "claude-sonnet"],
+    openrouter: [
+      "anthropic/claude-opus-4.8",
+      "anthropic/claude-sonnet-4.6:extended",
+      "anthropic/claude-sonnet-4.6",
+      "google/gemini-3-pro",
+    ],
+    deco: [
+      "anthropic/claude-opus",
+      "anthropic/claude-sonnet-4.6",
+      "anthropic/claude-sonnet",
+    ],
+    google: ["gemini-3-pro"],
+    "claude-code": ["claude-code:opus", "claude-code:sonnet"],
+    codex: ["codex:gpt-5.5"],
+  };
+
+/**
+ * Preferred image generation models per provider.
+ * Falls back to first model with "image" capability.
+ */
+export const IMAGE_MODEL_PREFERENCES: Partial<Record<ProviderId, string[]>> = {
+  openrouter: ["openai/gpt-image-1", "google/gemini-2.0-flash-image"],
+  deco: ["openai/gpt-image-1", "google/gemini-2.0-flash-image"],
+  google: ["gemini-2.0-flash-image"],
+};
+
+/**
+ * Preferred web research models per provider.
+ * Falls back to first model whose id includes "sonar" or "deepresearch".
+ */
+export const WEB_RESEARCH_MODEL_PREFERENCES: Partial<
+  Record<ProviderId, string[]>
+> = {
+  openrouter: [
+    "perplexity/sonar",
+    "perplexity/sonar-pro",
+    "perplexity/deep-research",
+  ],
+  deco: [
+    "perplexity/sonar",
+    "perplexity/sonar-pro",
+    "perplexity/deep-research",
+  ],
+};
+
+export interface SimpleModeModelSlot {
+  keyId: string;
+  modelId: string;
+  title?: string;
+}
+
+export interface SimpleModeDefaults {
+  chat: {
+    fast: SimpleModeModelSlot | null;
+    smart: SimpleModeModelSlot | null;
+    thinking: SimpleModeModelSlot | null;
+  };
+  image: SimpleModeModelSlot | null;
+  webResearch: SimpleModeModelSlot | null;
+}
+
+function resolveSlot(
+  models: AiProviderModel[],
+  keyId: string,
+  preferences: string[],
+  fallback?: (m: AiProviderModel) => boolean,
+): SimpleModeModelSlot | null {
+  for (const candidate of preferences) {
+    const exact = models.find((m) => m.modelId === candidate);
+    if (exact) return { keyId, modelId: exact.modelId, title: exact.title };
+  }
+  for (const candidate of preferences) {
+    const partial = models.find((m) => m.modelId.includes(candidate));
+    if (partial)
+      return { keyId, modelId: partial.modelId, title: partial.title };
+  }
+  if (fallback) {
+    const found = models.find(fallback);
+    if (found) return { keyId, modelId: found.modelId, title: found.title };
+  }
+  return null;
+}
+
+/**
+ * Compute sensible Simple Mode defaults from the currently-connected keys and
+ * their available models. Each slot picks the best candidate per the tier
+ * preference lists, falling back to capability-based detection for image/web.
+ *
+ * @param keys       The org's connected AI provider keys.
+ * @param modelsByKeyId  Map of keyId → available model list.
+ */
+export function pickSimpleModeDefaults(
+  keys: AiProviderKey[],
+  modelsByKeyId: Record<string, AiProviderModel[]>,
+): SimpleModeDefaults {
+  const result: SimpleModeDefaults = {
+    chat: { fast: null, smart: null, thinking: null },
+    image: null,
+    webResearch: null,
+  };
+
+  for (const key of keys) {
+    const models = modelsByKeyId[key.id] ?? [];
+    const providerId = key.providerId as ProviderId;
+
+    if (!result.chat.fast) {
+      result.chat.fast = resolveSlot(
+        models,
+        key.id,
+        FAST_MODEL_PREFERENCES[providerId] ?? [],
+      );
+    }
+    if (!result.chat.smart) {
+      result.chat.smart = resolveSlot(
+        models,
+        key.id,
+        SMART_MODEL_PREFERENCES[providerId] ?? [],
+      );
+    }
+    if (!result.chat.thinking) {
+      result.chat.thinking = resolveSlot(
+        models,
+        key.id,
+        THINKING_MODEL_PREFERENCES[providerId] ?? [],
+      );
+    }
+    if (!result.image) {
+      result.image = resolveSlot(
+        models,
+        key.id,
+        IMAGE_MODEL_PREFERENCES[providerId] ?? [],
+        (m) => m.capabilities?.includes("image") === true,
+      );
+    }
+    if (!result.webResearch) {
+      result.webResearch = resolveSlot(
+        models,
+        key.id,
+        WEB_RESEARCH_MODEL_PREFERENCES[providerId] ?? [],
+        (m) => {
+          const n = m.modelId.toLowerCase().replace(/[^a-z0-9]/g, "");
+          return n.includes("sonar") || n.includes("deepresearch");
+        },
+      );
+    }
+  }
+
+  return result;
+}
+
 /**
  * Select the best default model from a loaded list for a given provider.
  *

package/src/lib/mcp-oauth.ts

@@ -258,6 +258,10 @@ export interface OAuthTokenInfo {
   clientId: string | null;
   clientSecret: string | null;
   tokenEndpoint: string | null;
+  /** OIDC ID token (JWT) returned by some providers (e.g. Google). Contains user identity claims like email. */
+  idToken: string | null;
+  /** OIDC userinfo endpoint URL from authorization server metadata. Can be called with the access token to retrieve user identity. */
+  userinfoEndpoint: string | null;
 }
 
 /**
@@ -278,6 +282,7 @@ interface FullTokenResult {
   clientId: string | null;
   clientSecret: string | null;
   tokenEndpoint: string | null;
+  userinfoEndpoint: string | null;
 }
 
 /**
@@ -293,6 +298,8 @@ interface FullTokenResult {
  */
 export async function authenticateMcp(params: {
   connectionId: string;
+  /** Organization slug — used to build the org-scoped /api/:org/mcp/... URL. */
+  orgSlug?: string;
   /** Mesh server URL - optional, defaults to window.location.origin (for external apps, provide your Mesh server URL) */
   meshUrl?: string;
   clientName?: string;
@@ -305,7 +312,10 @@ export async function authenticateMcp(params: {
   windowMode?: OAuthWindowMode;
 }): Promise<AuthenticateMcpResult> {
   const baseUrl = params.meshUrl ?? window.location.origin;
-  const serverUrl = new URL(`/mcp/${params.connectionId}`, baseUrl);
+  const path = params.orgSlug
+    ? `/api/${encodeURIComponent(params.orgSlug)}/mcp/${params.connectionId}`
+    : `/mcp/${params.connectionId}`;
+  const serverUrl = new URL(path, baseUrl);
   const provider = new McpOAuthProvider({
     serverUrl: serverUrl.href,
     clientName: params.clientName,
@@ -424,6 +434,11 @@ export async function authenticateMcp(params: {
                   ? (clientInfo.client_secret as string)
                   : null,
               tokenEndpoint: authServerMetadata?.token_endpoint ?? null,
+              userinfoEndpoint:
+                (authServerMetadata?.userinfo_endpoint as
+                  | string
+                  | null
+                  | undefined) ?? null,
             });
           } catch (err) {
             cleanup();
@@ -473,6 +488,7 @@ export async function authenticateMcp(params: {
 
     if (result === "REDIRECT") {
       const fullResult = await oauthCompletePromise;
+      const rawTokens = fullResult.tokens as unknown as Record<string, unknown>;
       return {
         token: fullResult.tokens.access_token,
         tokenInfo: {
@@ -483,6 +499,9 @@ export async function authenticateMcp(params: {
           clientId: fullResult.clientId,
           clientSecret: fullResult.clientSecret,
           tokenEndpoint: fullResult.tokenEndpoint,
+          userinfoEndpoint: fullResult.userinfoEndpoint,
+          idToken:
+            typeof rawTokens.id_token === "string" ? rawTokens.id_token : null,
         },
         error: null,
       };
@@ -491,6 +510,7 @@ export async function authenticateMcp(params: {
     // If we got here without redirect, check for tokens
     const tokens = provider.tokens();
     const clientInfo = provider.clientInformation();
+    const rawTokens = tokens as unknown as Record<string, unknown> | null;
     return {
       token: tokens?.access_token || null,
       tokenInfo: tokens
@@ -505,6 +525,11 @@ export async function authenticateMcp(params: {
                 ? (clientInfo.client_secret as string)
                 : null,
             tokenEndpoint: null, // Would need to be passed through
+            userinfoEndpoint: null,
+            idToken:
+              rawTokens && typeof rawTokens.id_token === "string"
+                ? rawTokens.id_token
+                : null,
           }
         : null,
       error: null,
@@ -680,14 +705,32 @@ function getCurrentOrigin(): string | undefined {
 }
 
 /**
- * Extract connection ID from MCP proxy URL
+ * Extract connection ID from MCP proxy URL.
+ * Supports both legacy `/mcp/:id` and org-scoped `/api/:org/mcp/:id` paths.
  */
 function extractConnectionIdFromUrl(url: string): string | null {
   try {
     // Use current origin as base for relative URLs (browser only)
     const base = getCurrentOrigin();
     const urlObj = base ? new URL(url, base) : new URL(url);
-    const match = urlObj.pathname.match(/^\/mcp\/([^/]+)/);
+    const orgScoped = urlObj.pathname.match(/^\/api\/[^/]+\/mcp\/([^/]+)/);
+    if (orgScoped) return orgScoped[1] ?? null;
+    const legacy = urlObj.pathname.match(/^\/mcp\/([^/]+)/);
+    return legacy?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract org slug from an org-scoped MCP proxy URL (`/api/:org/mcp/...`).
+ * Returns null for legacy `/mcp/...` URLs.
+ */
+function extractOrgSlugFromUrl(url: string): string | null {
+  try {
+    const base = getCurrentOrigin();
+    const urlObj = base ? new URL(url, base) : new URL(url);
+    const match = urlObj.pathname.match(/^\/api\/([^/]+)\/mcp\//);
     return match?.[1] ?? null;
   } catch {
     return null;
@@ -697,14 +740,16 @@ function extractConnectionIdFromUrl(url: string): string | null {
 /**
  * Check if connection has a stored OAuth token
  * @param connectionId - The connection ID to check
+ * @param orgSlug - Organization slug used to build the org-scoped path
  * @param apiBaseUrl - Base URL for the API call (optional, defaults to relative path)
  */
 async function checkOAuthTokenStatus(
   connectionId: string,
+  orgSlug: string,
   apiBaseUrl?: string,
 ): Promise<{ hasToken: boolean }> {
   try {
-    const path = `/api/connections/${connectionId}/oauth-token/status`;
+    const path = `/api/${encodeURIComponent(orgSlug)}/connections/${connectionId}/oauth-token/status`;
     const url = apiBaseUrl ? new URL(path, apiBaseUrl).href : path;
     const currentOrigin = getCurrentOrigin();
     const isSameOrigin =
@@ -724,17 +769,21 @@ async function checkOAuthTokenStatus(
 
 /**
  * Check if an MCP connection is authenticated and whether it supports OAuth
- * @param params.url - The MCP URL to check
+ * @param params.url - The org-scoped MCP URL to check (`/api/:org/mcp/...`)
  * @param params.token - Authorization token (optional)
+ * @param params.orgId - Organization ID (deprecated; org is now resolved from the URL path)
  * @param params.meshUrl - Mesh server URL for API calls (optional, defaults to URL origin)
  */
 export async function isConnectionAuthenticated({
   url,
   token,
+  orgId: _orgId,
   meshUrl,
 }: {
   url: string;
   token: string | null;
+  /** @deprecated Org is resolved from the URL path; this is kept for call-site compatibility. */
+  orgId?: string;
   /** Mesh server URL for API calls - optional, defaults to extracting from url parameter */
   meshUrl?: string;
 }): Promise<McpAuthStatus> {
@@ -766,6 +815,7 @@ export async function isConnectionAuthenticated({
 
     // Extract connection ID for OAuth token status check
     const connectionId = extractConnectionIdFromUrl(url);
+    const orgSlug = extractOrgSlugFromUrl(url);
     // Determine base URL for API calls (meshUrl > URL origin > current origin)
     // Use current origin as base for relative URLs (browser only)
     const base = getCurrentOrigin();
@@ -774,9 +824,10 @@ export async function isConnectionAuthenticated({
 
     if (response.ok) {
       // Check if we have an OAuth token stored for this connection
-      const oauthStatus = connectionId
-        ? await checkOAuthTokenStatus(connectionId, apiBaseUrl)
-        : { hasToken: false };
+      const oauthStatus =
+        connectionId && orgSlug
+          ? await checkOAuthTokenStatus(connectionId, orgSlug, apiBaseUrl)
+          : { hasToken: false };
 
       return {
         isAuthenticated: true,

package/src/lib/query-keys.ts

@@ -15,10 +15,10 @@ export const KEYS = {
   threads: (locator: string) => ["threads", locator] as const,
   virtualMcpThreads: (locator: string, virtualMcpId: string) =>
     ["threads", locator, "virtual-mcp", virtualMcpId] as const,
-  thread: (locator: string, threadId: string) =>
-    ["thread", locator, threadId] as const,
-  threadMessages: (locator: string, threadId: string) =>
-    ["thread-messages", locator, threadId] as const,
+  thread: (locator: string, taskId: string) =>
+    ["thread", locator, taskId] as const,
+  threadMessages: (locator: string, taskId: string) =>
+    ["thread-messages", locator, taskId] as const,
   messages: (locator: string) => ["messages", locator] as const,
 
   // Organizations list
@@ -81,6 +81,10 @@ export const KEYS = {
   // Models list (scoped by organization)
   modelsList: (orgId: string) => ["models-list", orgId] as const,
 
+  // Virtual MCP last-used info (most recent thread per agent)
+  virtualMcpLastUsed: (orgId: string, ids: string[]) =>
+    ["virtual-mcp", "last-used", orgId, ids] as const,
+
   // Collections (scoped by connection)
   connectionCollections: (connectionId: string) =>
     [connectionId, "collections", "discovery"] as const,
@@ -149,6 +153,13 @@ export const KEYS = {
     owner: string | null | undefined,
     repo: string | null | undefined,
   ) => ["github-readme", owner, repo] as const,
+  githubBranches: (
+    orgId: string,
+    orgSlug: string,
+    connectionId: string | null | undefined,
+    owner: string,
+    repo: string,
+  ) => ["github-branches", orgId, orgSlug, connectionId, owner, repo] as const,
 
   // Monitoring queries
   monitoringStats: () => ["monitoring", "stats"] as const,
@@ -176,4 +187,8 @@ export const KEYS = {
 
   // User data
   user: (userId: string) => ["user", userId] as const,
+
+  // Registry app lookup (by app ID)
+  registryApp: (orgId: string, appId: string) =>
+    ["registry-app", orgId, appId] as const,
 } as const;

package/src/lib/server-client-bridge.ts

@@ -1,146 +1,4 @@
-/**
- * Server-Client Bridge
- *
- * Creates an MCP Server that delegates all requests to an MCP Client.
- * This allows using a Client as if it were a Server, useful for proxying
- * or bridging between different transport layers.
- *
- * ## Usage
- *
- * ```ts
- * import { createServerFromClient } from "@decocms/mesh-sdk";
- * import { Client } from "@modelcontextprotocol/sdk/client/index.js";
- * import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
- *
- * const client = new Client(...);
- * await client.connect(clientTransport);
- *
- * const server = createServerFromClient(
- *   client,
- *   { name: "proxy-server", version: "1.0.0" }
- * );
- *
- * const transport = new WebStandardStreamableHTTPServerTransport({});
- * await server.connect(transport);
- *
- * // Handle requests via transport.handleRequest(req)
- * ```
- */
-
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type {
-  Implementation,
-  ServerCapabilities,
-} from "@modelcontextprotocol/sdk/types.js";
-import {
-  CallToolRequestSchema,
-  GetPromptRequestSchema,
-  ListPromptsRequestSchema,
-  ListResourcesRequestSchema,
-  ListResourceTemplatesRequestSchema,
-  ListToolsRequestSchema,
-  ReadResourceRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-/**
- * Options for creating a server from a client
- */
-export interface ServerFromClientOptions {
-  /**
-   * Server capabilities. If not provided, uses client.getServerCapabilities()
-   */
-  capabilities?: ServerCapabilities;
-  /**
-   * Server instructions. If not provided, uses client.getInstructions()
-   */
-  instructions?: string;
-  /**
-   * Timeout in milliseconds for tool calls forwarded to the client.
-   * If not provided, the MCP SDK default (60s) is used.
-   */
-  toolCallTimeoutMs?: number;
-}
-
-/**
- * Creates an MCP Server that delegates all requests to the provided Client.
- *
- * @param client - The MCP Client to delegate requests to
- * @param serverInfo - Server metadata (ImplementationSchema-compatible: name, version, title, description, icons, websiteUrl)
- * @param options - Optional server configuration (capabilities and instructions)
- * @returns An MCP Server instance configured to delegate to the client
- */
-export function createServerFromClient(
-  client: Client,
-  serverInfo: Implementation,
-  options?: ServerFromClientOptions,
-): McpServer {
-  // Get capabilities from client if not provided
-  const capabilities = options?.capabilities ?? client.getServerCapabilities();
-
-  // Get instructions from client if not provided
-  const instructions = options?.instructions ?? client.getInstructions();
-
-  // Create MCP server with capabilities and instructions
-  const server = new McpServer(serverInfo, {
-    capabilities,
-    instructions,
-  });
-
-  // Set up request handlers that delegate to client methods
-
-  // Tools handlers
-  // Strip outputSchema from tools so downstream clients (e.g. the browser's
-  // MCP Client) don't cache validators and reject structuredContent that
-  // doesn't perfectly match the downstream server's declared schema.
-  // A proxy should pass through responses as-is — validation is the
-  // responsibility of the originating server, not intermediaries.
-  server.server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const result = await client.listTools();
-    return {
-      ...result,
-      tools: result.tools.map(({ outputSchema: _, ...tool }) => tool),
-    };
-  });
-
-  server.server.setRequestHandler(CallToolRequestSchema, (request) =>
-    client.callTool(
-      request.params,
-      undefined,
-      options?.toolCallTimeoutMs
-        ? { timeout: options.toolCallTimeoutMs }
-        : undefined,
-    ),
-  );
-
-  // Resources handlers (only if capabilities include resources)
-  if (capabilities?.resources) {
-    server.server.setRequestHandler(ListResourcesRequestSchema, () =>
-      client.listResources(),
-    );
-
-    server.server.setRequestHandler(ReadResourceRequestSchema, (request) =>
-      client.readResource(request.params),
-    );
-
-    server.server.setRequestHandler(ListResourceTemplatesRequestSchema, () =>
-      client.listResourceTemplates(),
-    );
-  }
-
-  // Prompts handlers (only if capabilities include prompts)
-  if (capabilities?.prompts) {
-    server.server.setRequestHandler(ListPromptsRequestSchema, () =>
-      client.listPrompts(),
-    );
-
-    server.server.setRequestHandler(GetPromptRequestSchema, (request) =>
-      client.getPrompt({
-        ...request.params,
-        arguments: request.params.arguments ?? {},
-      }),
-    );
-  }
-
-  return server;
-}
+export {
+  createServerFromClient,
+  type ServerFromClientOptions,
+} from "@decocms/mcp-utils";

package/src/lib/usage.test.ts

@@ -160,4 +160,70 @@ describe("addUsage", () => {
     const result = addUsage(acc, null);
     expect(result).toBe(acc);
   });
+
+  test("accumulates cache tokens from inputTokenDetails", () => {
+    const acc = emptyUsageStats();
+    const step = {
+      inputTokens: 1000,
+      outputTokens: 50,
+      inputTokenDetails: {
+        cacheReadTokens: 800,
+        cacheWriteTokens: 100,
+      },
+    };
+    const result = addUsage(acc, step);
+    expect(result.cacheReadTokens).toBe(800);
+    expect(result.cacheWriteTokens).toBe(100);
+  });
+
+  test("falls back to cachedInputTokens when inputTokenDetails is absent", () => {
+    const acc = emptyUsageStats();
+    const step = {
+      inputTokens: 1000,
+      outputTokens: 50,
+      cachedInputTokens: 600,
+    };
+    const result = addUsage(acc, step);
+    expect(result.cacheReadTokens).toBe(600);
+    expect(result.cacheWriteTokens).toBe(0);
+  });
+
+  test("inputTokenDetails takes precedence over cachedInputTokens", () => {
+    const acc = emptyUsageStats();
+    const step = {
+      inputTokens: 1000,
+      cachedInputTokens: 999, // would be wrong
+      inputTokenDetails: { cacheReadTokens: 800, cacheWriteTokens: 0 },
+    };
+    const result = addUsage(acc, step);
+    expect(result.cacheReadTokens).toBe(800);
+  });
+});
+
+describe("calculateUsageStats — cache fields", () => {
+  test("sums cache read/write across messages", () => {
+    const messages = [
+      {
+        metadata: {
+          usage: {
+            inputTokens: 100,
+            outputTokens: 50,
+            inputTokenDetails: { cacheReadTokens: 80, cacheWriteTokens: 10 },
+          },
+        },
+      },
+      {
+        metadata: {
+          usage: {
+            inputTokens: 200,
+            outputTokens: 25,
+            inputTokenDetails: { cacheReadTokens: 150 },
+          },
+        },
+      },
+    ];
+    const result = calculateUsageStats(messages);
+    expect(result.cacheReadTokens).toBe(230);
+    expect(result.cacheWriteTokens).toBe(10);
+  });
 });