@vellumai/assistant 0.11.2-dev.202608050137.0c8f50a → 0.11.2-dev.202608050507.7e832db

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.2-dev.202608050137.0c8f50a",
+  "version": "0.11.2-dev.202608050507.7e832db",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/anthropic-provider.test.ts

@@ -1410,9 +1410,11 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(sent[2].content[0].type).toBe("text");
   });
 
-  test("orphaned server_tool_use at end of messages gets synthetic result (no synthetic user append)", async () => {
-    // Orphaned server_tool_use at the end should get a synthetic
-    // web_search_tool_result but no synthetic user message.
+  test("unanswered server_tool_use in the final assistant message is left intact for deferred execution", async () => {
+    // When the final assistant message ends with an unanswered
+    // server_tool_use, the API executes the search on this request (the
+    // pause_turn / deferred-execution contract). The tail must go back
+    // verbatim with no synthetic result, or the search is cancelled.
     const messages: Message[] = [
       userMsg("Search something"),
       {
@@ -1434,12 +1436,11 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       content: Array<{ type: string; tool_use_id?: string }>;
     }>;
 
-    // Original 2 messages, with synthetic result injected in assistant message
+    // Original 2 messages, assistant tail verbatim: no synthetic result
     expect(sent).toHaveLength(2);
     expect(sent[1].role).toBe("assistant");
+    expect(sent[1].content).toHaveLength(1);
     expect(sent[1].content[0].type).toBe("server_tool_use");
-    expect(sent[1].content[1].type).toBe("web_search_tool_result");
-    expect(sent[1].content[1].tool_use_id).toBe("srvtoolu_end");
   });
 
   test("server_tool_use with matching web_search_tool_result passes through unchanged", async () => {
@@ -1568,7 +1569,11 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(webSearchResults[0].tool_use_id).toBe("srvtoolu_search");
   });
 
-  test("mixed tool_use and server_tool_use — only client-side tool_use gets pairing, server tools pass through", async () => {
+  test("mixed tool_use and deferred server_tool_use tail goes out verbatim", async () => {
+    // The mixed parallel group is the deferred-execution trigger: the API
+    // returns stop_reason tool_use without running the search, and runs it on
+    // the next request when the client tool results come back with the
+    // assistant message unchanged. No split, no synthetic result.
     const messages: Message[] = [
       userMsg("Do things"),
       {
@@ -1583,7 +1588,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
           },
         ],
       },
-      // Only tu_a has a result — server_tool_use doesn't need one in the user message
+      // Only tu_a has a result; the deferred search has none yet
       toolResultMsg("tu_a", "result A"),
     ];
     await provider.sendMessage(messages);
@@ -1597,27 +1602,139 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       }>;
     }>;
 
-    // Assistant message should have tool_use in paired portion, server_tool_use in carryover
-    // ensureToolPairing splits: paired = [tool_use(tu_a)], carryover = [server_tool_use(srvtoolu_b)]
-    // Result: assistant(tool_use) → user(tool_result) → assistant(server_tool_use) → user(synthetic_continuation)
+    // assistant(tool_use, server_tool_use) → user(tool_result), verbatim
+    expect(sent).toHaveLength(3);
     const assistantMsg = sent[1];
     expect(assistantMsg.role).toBe("assistant");
-    expect(assistantMsg.content[0].type).toBe("tool_use");
+    expect(assistantMsg.content.map((b) => b.type)).toEqual([
+      "tool_use",
+      "server_tool_use",
+    ]);
 
     const userAfterAssistant = sent[2];
     expect(userAfterAssistant.role).toBe("user");
-    // Only tool_result for tu_a — no synthetic web_search_tool_result
     expect(userAfterAssistant.content[0]).toMatchObject({
       type: "tool_result",
       tool_use_id: "tu_a",
     });
 
-    // server_tool_use preserved in a carryover assistant message with synthetic result
-    const carryoverAssistant = sent[3];
-    expect(carryoverAssistant.role).toBe("assistant");
-    expect(carryoverAssistant.content[0].type).toBe("server_tool_use");
-    expect(carryoverAssistant.content[1].type).toBe("web_search_tool_result");
-    expect(carryoverAssistant.content[1].tool_use_id).toBe("srvtoolu_b");
+    // No synthetic web_search_tool_result anywhere; the API runs the search
+    const allBlocks = sent.flatMap((m) => m.content);
+    expect(
+      allBlocks.filter((b) => b.type === "web_search_tool_result"),
+    ).toHaveLength(0);
+  });
+
+  test("deferred mixed heartbeat shape with text and multiple searches goes out verbatim", async () => {
+    const messages: Message[] = [
+      userMsg("Heartbeat: check the file and the news"),
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Checking both." },
+          { type: "tool_use", id: "tu_read", name: "file_read", input: {} },
+          {
+            type: "server_tool_use",
+            id: "srvtoolu_s1",
+            name: "web_search",
+            input: { query: "news one" },
+          },
+          {
+            type: "server_tool_use",
+            id: "srvtoolu_s2",
+            name: "web_search",
+            input: { query: "news two" },
+          },
+        ],
+      },
+      toolResultMsg("tu_read", "file contents"),
+    ];
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{ type: string; id?: string; tool_use_id?: string }>;
+    }>;
+
+    expect(sent).toHaveLength(3);
+    expect(sent[1].content.map((b) => b.type)).toEqual([
+      "text",
+      "tool_use",
+      "server_tool_use",
+      "server_tool_use",
+    ]);
+    const allBlocks = sent.flatMap((m) => m.content);
+    expect(
+      allBlocks.filter((b) => b.type === "web_search_tool_result"),
+    ).toHaveLength(0);
+  });
+
+  test("cross-message server tool pair from a completed deferred execution is preserved verbatim", async () => {
+    // After a deferred search executes, history carries the split pair: the
+    // server_tool_use in one assistant message and its web_search_tool_result
+    // heading the next assistant message. Both sides must pass through
+    // untouched: no synthetic result on the use, no text downgrade on the
+    // result.
+    const messages: Message[] = [
+      userMsg("Check the file and the news"),
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "On it." },
+          { type: "tool_use", id: "tu_a", name: "file_read", input: {} },
+          {
+            type: "server_tool_use",
+            id: "srvtoolu_deferred",
+            name: "web_search",
+            input: { query: "news" },
+          },
+        ],
+      },
+      toolResultMsg("tu_a", "file contents"),
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_deferred",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://example.com",
+                title: "Example",
+                encrypted_content: "enc_deferred",
+              },
+            ],
+          },
+          { type: "text", text: "Here is the news." },
+        ],
+      },
+      userMsg("thanks, anything else?"),
+    ];
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{ type: string; id?: string; tool_use_id?: string }>;
+    }>;
+
+    expect(sent).toHaveLength(5);
+    expect(sent[1].content.map((b) => b.type)).toEqual([
+      "text",
+      "tool_use",
+      "server_tool_use",
+    ]);
+    expect(sent[3].content.map((b) => b.type)).toEqual([
+      "web_search_tool_result",
+      "text",
+    ]);
+    // Exactly the original result block, still a result block
+    const allBlocks = sent.flatMap((m) => m.content);
+    const results = allBlocks.filter(
+      (b) => b.type === "web_search_tool_result",
+    );
+    expect(results).toHaveLength(1);
+    expect(results[0].tool_use_id).toBe("srvtoolu_deferred");
   });
 
   test("orphaned server_tool_use from interrupted stream gets repaired in multi-turn conversation", async () => {

package/src/__tests__/history-repair.test.ts

@@ -572,8 +572,10 @@ describe("repairHistory", () => {
     ).toBe(true);
   });
 
-  test("trailing server_tool_use gets synthetic result in same assistant message", () => {
-    // No trailing user message needed — result goes in the assistant message
+  test("trailing server_tool_use is preserved as a deferred execution", () => {
+    // An unanswered server_tool_use at the tail is a deferred search the
+    // provider executes on the next request; repairing it would cancel the
+    // search.
     const messages: Message[] = [
       { role: "user", content: [{ type: "text", text: "Go" }] },
       {
@@ -591,21 +593,107 @@ describe("repairHistory", () => {
 
     const { messages: repaired, stats } = repairHistory(messages);
 
-    expect(stats.missingToolResultsInserted).toBe(1);
-    // Result is in the assistant message
+    expect(stats.missingToolResultsInserted).toBe(0);
     expect(repaired).toHaveLength(2);
     expect(repaired[1].role).toBe("assistant");
-    expect(repaired[1].content).toHaveLength(2);
-    expect(repaired[1].content[1]).toMatchObject({
-      type: "web_search_tool_result",
-      tool_use_id: "stu_1",
-      content: {
-        type: "web_search_tool_result_error",
-        error_code: "unavailable",
-      },
+    expect(repaired[1].content).toHaveLength(1);
+    expect(repaired[1].content[0]).toMatchObject({
+      type: "server_tool_use",
+      id: "stu_1",
     });
   });
 
+  test("deferred mixed tail (tool_use + server_tool_use, then tool_result) survives a reload untouched", () => {
+    // Persisted mid-deferral shape: the model called a client tool and a
+    // search in one parallel group, the client result came back, and the
+    // daemon reloaded before the next model call ran the search.
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Check both" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "tu_a", name: "file_read", input: {} },
+          {
+            type: "server_tool_use",
+            id: "stu_deferred",
+            name: "web_search",
+            input: { query: "news" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "tu_a", content: "file" },
+        ],
+      },
+    ];
+
+    const { messages: repaired, stats } = repairHistory(messages);
+
+    expect(stats.missingToolResultsInserted).toBe(0);
+    expect(stats.orphanToolResultsDowngraded).toBe(0);
+    expect(repaired).toHaveLength(3);
+    expect(repaired[1].content.map((b) => b.type)).toEqual([
+      "tool_use",
+      "server_tool_use",
+    ]);
+  });
+
+  test("cross-message server tool pair from a completed deferred execution survives a reload untouched", () => {
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Check both" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "tu_a", name: "file_read", input: {} },
+          {
+            type: "server_tool_use",
+            id: "stu_split",
+            name: "web_search",
+            input: { query: "news" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "tu_a", content: "file" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "stu_split",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://example.com",
+                title: "Example",
+              },
+            ],
+          },
+          { type: "text", text: "Found it." },
+        ],
+      },
+    ];
+
+    const { messages: repaired, stats } = repairHistory(messages);
+
+    expect(stats.missingToolResultsInserted).toBe(0);
+    expect(stats.orphanToolResultsDowngraded).toBe(0);
+    expect(repaired[1].content.map((b) => b.type)).toEqual([
+      "tool_use",
+      "server_tool_use",
+    ]);
+    expect(repaired[3].content.map((b) => b.type)).toEqual([
+      "web_search_tool_result",
+      "text",
+    ]);
+  });
+
   test("synthetic web_search_tool_result is placed immediately after its server_tool_use, not at end", () => {
     // Regression: synthetic results appended to the end of the content array
     // get separated from their server_tool_use by ensureToolPairing's split
@@ -648,6 +736,12 @@ describe("repairHistory", () => {
           },
         ],
       },
+      // A later assistant message closes the deferral window: the searches
+      // never executed, so they are genuine orphans.
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Skill ready." }],
+      },
     ];
 
     const { messages: repaired, stats } = repairHistory(messages);
@@ -866,6 +960,12 @@ describe("repairHistory", () => {
           },
         ],
       },
+      // A later exchange closes the deferral window for stu_missing_result.
+      { role: "user", content: [{ type: "text", text: "and?" }] },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "done" }],
+      },
     ];
 
     const { messages: repaired, stats } = repairHistory(messages);

package/src/__tests__/oauth-provider-profiles.test.ts

@@ -23,7 +23,7 @@ describe("oauth provider profiles (DB-seeded)", () => {
     );
   });
 
-  test("google provider row contains bearer injection templates for 4 Google API hosts", () => {
+  test("google provider row contains bearer injection templates for 6 Google API hosts", () => {
     const provider = getProvider("google");
 
     expect(provider).toBeDefined();
@@ -36,7 +36,7 @@ describe("oauth provider profiles (DB-seeded)", () => {
       valuePrefix: string;
     }>;
 
-    expect(templates).toHaveLength(4);
+    expect(templates).toHaveLength(6);
 
     const byHost = new Map(templates.map((t) => [t.hostPattern, t]));
 
@@ -45,6 +45,8 @@ describe("oauth provider profiles (DB-seeded)", () => {
       "www.googleapis.com",
       "people.googleapis.com",
       "docs.googleapis.com",
+      "tasks.googleapis.com",
+      "calendar.googleapis.com",
     ]) {
       const tpl = byHost.get(host);
       expect(tpl).toBeDefined();

package/src/__tests__/ui-choice-copy-surfaces.test.ts

@@ -204,6 +204,7 @@ describe("choice and copy_block surface proxying", () => {
       providerKey: "google",
       displayName: "Google",
       description: "Connect Gmail for this task.",
+      requestedScopes: ["gmail.readonly"],
     });
     expect(ctx.pendingSurfaceActions.get(showMessage.surfaceId)).toEqual({
       surfaceType: "oauth_connect",

package/src/__tests__/web-search-history.test.ts

@@ -328,4 +328,100 @@ describe("stripHistoricalWebSearchResults", () => {
     const afterTypes = messages[0].content.map((b) => b.type);
     expect(afterTypes).toEqual(beforeTypes);
   });
+
+  test("drops the server_tool_use of a cross-message pair from a deferred execution", () => {
+    // Deferred execution places the web_search_tool_result at the head of the
+    // assistant message after the client tool round-trip. Both sides of the
+    // pair must go together, or the leftover server_tool_use reads as an
+    // orphan and gets a synthetic error result downstream.
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Check both" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "On it" },
+          { type: "tool_use", id: "tu_read", name: "file_read", input: {} },
+          {
+            type: "server_tool_use",
+            id: "stu_deferred",
+            name: "web_search",
+            input: { query: "deferred query" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "tu_read", content: "file" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "stu_deferred",
+            content: [
+              {
+                type: "web_search_result",
+                url: "https://example.com",
+                title: "Deferred",
+                encrypted_content: "tok",
+              },
+            ],
+          },
+          { type: "text", text: "Found it." },
+        ],
+      },
+    ];
+
+    const { messages: result, stats } =
+      stripHistoricalWebSearchResults(messages);
+
+    // The use in the earlier assistant message is dropped with its result
+    expect(result[1].content.map((b) => b.type)).toEqual(["text", "tool_use"]);
+    const summarized = result[3].content[0];
+    expect(summarized.type).toBe("text");
+    expect((summarized as { text: string }).text).toContain("deferred query");
+    expect((summarized as { text: string }).text).toContain(
+      "https://example.com",
+    );
+    expect(stats.serverToolUsesDropped).toBe(1);
+    expect(stats.blocksStripped).toBe(1);
+    expect(stats.messagesModified).toBe(2);
+  });
+
+  test("leaves a pending server_tool_use with no result anywhere untouched", () => {
+    // A resultless use at the tail is a deferred search the provider executes
+    // on this request; stripping it would cancel the search.
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Check both" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "tu_read", name: "file_read", input: {} },
+          {
+            type: "server_tool_use",
+            id: "stu_pending",
+            name: "web_search",
+            input: { query: "pending" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "tu_read", content: "file" },
+        ],
+      },
+    ];
+
+    const { messages: result, stats } =
+      stripHistoricalWebSearchResults(messages);
+
+    expect(result).toEqual(messages);
+    expect(stats.serverToolUsesDropped).toBe(0);
+    expect(stats.blocksStripped).toBe(0);
+    expect(stats.messagesModified).toBe(0);
+  });
 });

package/src/agent/history-repair/history-repair.ts

@@ -15,6 +15,7 @@
  * recover — so detection and repair of ordering drift live together as one unit.
  */
 
+import { analyzeServerToolPairing } from "../../providers/server-tool-pairing.js";
 import type {
   ContentBlock,
   Message,
@@ -69,6 +70,10 @@ export function repairHistory(messages: Message[]): RepairResult {
   let pendingToolUseIds = new Set<string>();
   // tool_result blocks stripped from assistant messages, keyed by tool_use_id
   let recoveredResults = new Map<string, ToolResultContent>();
+  // Server-tool pairs can legitimately span messages (deferred execution) or
+  // sit unanswered at the tail (the provider runs the search on the next
+  // request), so orphanhood is judged against the whole list, not per message.
+  const serverToolPairing = analyzeServerToolPairing(messages);
 
   for (const [msgIndex, msg] of messages.entries()) {
     if (msg.role === "assistant") {
@@ -100,36 +105,32 @@ export function repairHistory(messages: Message[]): RepairResult {
         }
       }
 
-      // Pair server-side tool blocks within the same assistant message.
-      // Server tools (e.g. web_search) emit server_tool_use + matching
-      // web_search_tool_result. Either side can go missing — the synthetic
-      // result is inserted IMMEDIATELY AFTER the orphan server_tool_use (not
+      // Repair orphaned server-side tool blocks. Server tools (e.g.
+      // web_search) emit server_tool_use + matching web_search_tool_result;
+      // orphanhood comes from `serverToolPairing`, which resolves pairs
+      // across messages and exempts the deferred tail. The synthetic result
+      // is inserted IMMEDIATELY AFTER the orphan server_tool_use (not
       // appended to the end) so ensureToolPairing's split at tool_use
       // boundaries cannot separate the pair. An orphan
-      // web_search_tool_result (no preceding server_tool_use) is downgraded
-      // to text — Anthropic rejects the request otherwise.
-      const serverToolIds = new Set(
-        cleanedContent
-          .filter(
-            (b): b is ServerToolUseContent => b.type === "server_tool_use",
-          )
-          .map((b) => b.id),
-      );
-      const matchedServerIds = new Set(
-        cleanedContent
-          .filter((b) => b.type === "web_search_tool_result")
-          .map((b) => (b as { tool_use_id: string }).tool_use_id),
-      );
+      // web_search_tool_result with no use anywhere is downgraded to text.
+      // Anthropic rejects the request otherwise.
       const orphanedServerIds = new Set<string>();
-      for (const id of serverToolIds) {
-        if (!matchedServerIds.has(id)) {
-          orphanedServerIds.add(id);
-        }
-      }
       const orphanedWebSearchResultIds = new Set<string>();
-      for (const id of matchedServerIds) {
-        if (!serverToolIds.has(id)) {
-          orphanedWebSearchResultIds.add(id);
+      for (const b of cleanedContent) {
+        if (b.type === "server_tool_use") {
+          const id = (b as ServerToolUseContent).id;
+          if (
+            !serverToolPairing.resolvedPairIds.has(id) &&
+            !serverToolPairing.deferredUseIds.has(id)
+          ) {
+            orphanedServerIds.add(id);
+          }
+        }
+        if (b.type === "web_search_tool_result") {
+          const id = (b as { tool_use_id: string }).tool_use_id;
+          if (!serverToolPairing.resolvedPairIds.has(id)) {
+            orphanedWebSearchResultIds.add(id);
+          }
         }
       }
 

package/src/api/surfaces-oauth-connect.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  type OAuthConnectSurfaceData,
+  OAuthConnectSurfaceDataSchema,
+} from "./surfaces.js";
+
+describe("OAuthConnectSurfaceDataSchema requestedScopes", () => {
+  test("parses a valid scopes array and preserves order", () => {
+    const parsed = OAuthConnectSurfaceDataSchema.parse({
+      providerKey: "google",
+      requestedScopes: [
+        "https://www.googleapis.com/auth/tasks",
+        "https://www.googleapis.com/auth/calendar",
+        "openid",
+      ],
+    });
+    expect(parsed.requestedScopes).toEqual([
+      "https://www.googleapis.com/auth/tasks",
+      "https://www.googleapis.com/auth/calendar",
+      "openid",
+    ]);
+  });
+
+  test("absent requestedScopes parses to undefined", () => {
+    const parsed = OAuthConnectSurfaceDataSchema.parse({
+      providerKey: "google",
+    });
+    expect(parsed.requestedScopes).toBeUndefined();
+  });
+
+  test("an empty array collapses to undefined", () => {
+    const parsed = OAuthConnectSurfaceDataSchema.parse({
+      providerKey: "google",
+      requestedScopes: [],
+    });
+    expect(parsed.requestedScopes).toBeUndefined();
+  });
+
+  test("non-array values collapse to undefined instead of rejecting", () => {
+    for (const value of [
+      "https://www.googleapis.com/auth/tasks, openid",
+      42,
+      true,
+      { scope: "openid" },
+      null,
+    ]) {
+      const parsed = OAuthConnectSurfaceDataSchema.parse({
+        providerKey: "google",
+        requestedScopes: value,
+      });
+      expect(parsed.requestedScopes).toBeUndefined();
+    }
+  });
+
+  test("an array of blanks collapses to undefined", () => {
+    const parsed = OAuthConnectSurfaceDataSchema.parse({
+      providerKey: "google",
+      requestedScopes: ["", "   ", "\t"],
+    });
+    expect(parsed.requestedScopes).toBeUndefined();
+  });
+
+  test("entries are trimmed and blank or non-string junk is dropped", () => {
+    const parsed = OAuthConnectSurfaceDataSchema.parse({
+      providerKey: "google",
+      requestedScopes: [
+        "  https://www.googleapis.com/auth/tasks  ",
+        "",
+        null,
+        { nope: true },
+        "openid",
+      ],
+    });
+    expect(parsed.requestedScopes).toEqual([
+      "https://www.googleapis.com/auth/tasks",
+      "openid",
+    ]);
+  });
+
+  test("a bare string is not split on commas (scopes are opaque URIs)", () => {
+    const parsed = OAuthConnectSurfaceDataSchema.parse({
+      providerKey: "google",
+      requestedScopes: "a,b,c",
+    });
+    expect(parsed.requestedScopes).toBeUndefined();
+  });
+
+  test("legacy payload { providerKey: 'google' } still parses (skew guard)", () => {
+    const parsed: OAuthConnectSurfaceData = OAuthConnectSurfaceDataSchema.parse(
+      { providerKey: "google" },
+    );
+    expect(parsed.providerKey).toBe("google");
+    expect(parsed.requestedScopes).toBeUndefined();
+  });
+});