@vellumai/assistant 0.5.4 → 0.5.5

package/src/memory/job-handlers/conversation-starters.ts

@@ -176,11 +176,11 @@ async function generateStarters(scopeId: string): Promise<GeneratedStarter[]> {
     ? truncate(rawIdentityContext, 2000, "\n…[truncated]")
     : null;
 
-  const systemPrompt = `You are generating 4 conversation starters for a personal assistant app. These appear as clickable chips on the empty conversation page — the first thing the user sees when they open the app.
+  const systemPrompt = `You are generating 4 conversation starters for a personal assistant app. These appear as clickable chips on the empty conversation page — the first thing the user sees when they open the app. Clicking a chip sends its prompt as a message from the user.
 
 ${timeContext}
 
-Your goal: look at what's going on in this person's life right now and suggest the 4 most useful things they could ask you to do. Think about what a thoughtful chief of staff would proactively bring up in a 30-second check-in.
+Your goal: suggest the 4 most useful things this person could ask you to do right now.
 
 ${identityContext ? `## Assistant identity & user profile\n\n${identityContext}\n\n` : ""}## What you know
 
@@ -188,7 +188,9 @@ ${rollup}
 ${diff}
 ${skills}
 
-## How to think about this
+## Selection
+
+Generate exactly 4 starters, ranked #1 (best) to #4.
 
 Start from the user's situation, not from the skill list. Ask yourself:
 - What is this person likely dealing with right now (given the day/time and their context)?
@@ -197,11 +199,7 @@ Start from the user's situation, not from the skill list. Ask yourself:
 
 The skills list tells you what the assistant CAN do — use it to filter out suggestions the assistant can't actually help with, not as a menu to generate suggestions from.
 
-## Selection
-
-Generate exactly 4 starters, ranked #1 (best) to #4.
-
-For each, you must be able to clearly answer:
+For each starter, you must clearly answer:
 - Why now? (timing — day of week, recent activity, upcoming deadline)
 - Why this user? (grounded in their specific context, not generic)
 - Why would they be glad I suggested this? (genuine usefulness, not just relevance)
@@ -218,44 +216,34 @@ Favor what is live over what is merely true. Recent changes matter more than old
 
 ## Output format
 
-Return exactly 4 starters in rank order (best first).
-
 Each starter has:
-- label: 3-6 words, max 40 chars, starts with a verb. Should read as something the user wants to do — these chips send a message as the user, so the label must be in the user's voice. Must sound natural when read aloud.
-- prompt: 1-2 natural sentences, written as the user would actually say them — not templated.
+- label: 3-6 words, max 40 chars, starts with a verb. Written in the user's voice — something they'd want to do, not something the assistant is offering.
+- prompt: 1-2 natural sentences, as the user would actually say them.
 - category: one of ${CONVERSATION_STARTER_CATEGORIES.join(", ")}
 
-The 4 starters should feel like one coherent set of recommendations for this moment — similar abstraction level, no jarring mix of mundane chores and life strategy. Don't lift raw memory phrases, project names, or jargon into labels unless they already sound natural in conversation.
-
-Never include a chip whose primary meaning is configuration, setup, workflow creation, or "set up X for Y" unless it solves an urgent pain the user is actively feeling right now. Prefer the outcome over the mechanism — "Catch the emails that matter" beats "Set up a playbook for inbox."
-
-## Topic diversity
-
-Each chip should cover a distinct topic or concern. Never have two chips about the same tool, project, or theme — even if there are multiple related issues. Pick the single most impactful angle and give the other slot to something different. Four chips about three topics is too narrow; four chips about four topics is right.
+## Constraints
 
-## User-facingness check
+**Voice**: The user clicks these chips to send a message. Every label must read as something the user is asking to do, never something the assistant is saying to the user.
 
-If a label sounds like an issue title, project ticket, or implementation task, rewrite it. Prefer the user-visible payoff over the internal object name. The chip should feel inviting and useful, not merely accurate.
+**Coherence**: The 4 starters should feel like one set — similar abstraction level, no jarring mix of mundane chores and life strategy.
 
-Prefer natural, flowing language over mechanical or operational phrasing. "Get Slack messages flowing" is better than "Restore outgoing Slack messages." The label should sound like something a helpful person would say, not a support ticket.
+**Diversity**: Each chip covers a distinct topic. Never two chips about the same tool, project, or theme. Four topics, four chips.
 
-Voice: The user clicks these chips to send a message. Every label must make sense as something the user is asking to do, never something the assistant is saying to the user.
+**No setup chips**: Never include a chip whose primary meaning is configuration or "set up X for Y" unless it solves an urgent pain the user is actively feeling. Prefer the outcome over the mechanism.
 
-Before finalizing each label, ask yourself: would this feel good to click? Or does it sound like a backlog item? If it sounds like a backlog item, rewrite it.
+**Natural language**: No jargon, project names, or raw memory phrases in labels unless they already sound natural in conversation. If a label sounds like a ticket title or backlog item, rewrite it as something the user would actually say.
 
-Examples of bad vs good:
-- BAD: "Fix Slack Socket Mode blocker" → GOOD: "Fix Slack so it just works"
-- BAD: "Rewire messaging for Socket Mode" → GOOD: "Get Socket Mode stable"
-- BAD: "Review this week's calendar" → GOOD: "Protect this week's focus"
-- BAD: "Model the coaching transition" → GOOD: "Plan the coaching transition"
-- BAD: "Restore outgoing Slack messages" → GOOD: "Get Slack messages flowing"
-- BAD: "Set up a playbook for inbox" → GOOD: "Catch the emails that matter"
+## Examples
 
-Assistant-voice vs user-voice:
-- BAD: "You've got a busy week ahead" → GOOD: "Plan my week ahead"
-- BAD: "Let me check your calendar" → GOOD: "Check my Thursday schedule"
+Bad → Good (ticket-speak → natural):
+- "Fix Slack Socket Mode blocker" → "Fix Slack so it just works"
+- "Restore outgoing Slack messages" → "Get Slack messages flowing"
+- "Review this week's calendar" → "Protect this week's focus"
+- "Set up a playbook for inbox" → "Triage my inbox"
 
-The good versions emphasize the user's payoff in the user's own voice, not the internal mechanism or the assistant's perspective.`;
+Bad → Good (assistant voice → user voice):
+- "You've got a busy week ahead" → "Plan my week ahead"
+- "Let me check your calendar" → "Check my Thursday schedule"`;
 
   const { signal, cleanup } = createTimeout(20000);
   try {
@@ -280,7 +268,7 @@ The good versions emphasize the user's payoff in the user's own voice, not the i
                     label: {
                       type: "string",
                       description:
-                        "User-voice chip text (2-7 words, max 40 chars, starts with a verb)",
+                        "User-voice chip label (2-7 words, max 40 chars, verb-first)",
                     },
                     prompt: {
                       type: "string",

package/src/messaging/provider.ts

@@ -89,6 +89,15 @@ export interface MessagingProvider {
    */
   isConnected?(): Promise<boolean>;
 
+  /**
+   * Custom credential resolution for providers with non-standard credential
+   * paths (e.g. Slack Socket Mode stores tokens under "slack_channel" rather
+   * than the OAuth provider key). When present, getProviderConnection() calls
+   * this instead of resolveOAuthConnection(), giving the provider full control
+   * over credential lookup including fallback strategies.
+   */
+  resolveConnection?(account?: string): Promise<OAuthConnection | string>;
+
   /** Platform-specific capabilities for tool routing (e.g. 'reactions', 'threads', 'labels'). */
   capabilities: Set<string>;
 }

package/src/messaging/providers/slack/adapter.ts

@@ -1,11 +1,15 @@
 /**
  * Slack messaging provider adapter.
  *
- * Maps Slack API responses to the platform-agnostic messaging types
- * and implements the MessagingProvider interface.
+ * Maps Slack API responses to the platform-agnostic messaging types and
+ * implements the MessagingProvider interface.
  */
 
 import type { OAuthConnection } from "../../../oauth/connection.js";
+import { resolveOAuthConnection } from "../../../oauth/connection-resolver.js";
+import { isProviderConnected } from "../../../oauth/oauth-store.js";
+import { credentialKey } from "../../../security/credential-key.js";
+import { getSecureKeyAsync } from "../../../security/secure-keys.js";
 import type { MessagingProvider } from "../../provider.js";
 import type {
   ConnectionInfo,
@@ -112,6 +116,29 @@ export const slackProvider: MessagingProvider = {
   credentialService: "integration:slack",
   capabilities: new Set(["reactions", "threads", "leave_channel"]),
 
+  async isConnected(): Promise<boolean> {
+    // Socket Mode: check for bot token directly in credential store.
+    // The token is the source of truth; the slack_channel connection row
+    // is advisory (backfill can fail non-fatally on startup).
+    const botToken = await getSecureKeyAsync(
+      credentialKey("slack_channel", "bot_token"),
+    );
+    if (botToken) return true;
+    // Preserve existing OAuth path (integration:slack) for backwards compat.
+    return isProviderConnected("integration:slack");
+  },
+
+  async resolveConnection(account?: string): Promise<OAuthConnection | string> {
+    // Socket Mode: return raw bot token if available.
+    // Token presence is sufficient — no connection row required.
+    const botToken = await getSecureKeyAsync(
+      credentialKey("slack_channel", "bot_token"),
+    );
+    if (botToken) return botToken;
+    // Preserve existing OAuth path (integration:slack) for backwards compat.
+    return resolveOAuthConnection("integration:slack", { account });
+  },
+
   async testConnection(
     connectionOrToken: OAuthConnection | string,
   ): Promise<ConnectionInfo> {

package/src/oauth/connection-resolver.test.ts

@@ -8,12 +8,7 @@ let mockProvider: Record<string, unknown> | undefined;
 let mockConnection: Record<string, unknown> | undefined;
 let mockAccessToken: string | undefined;
 let mockConfig: Record<string, unknown> = {};
-let mockManagedProxyCtx = {
-  enabled: false,
-  platformBaseUrl: "",
-  assistantApiKey: "",
-};
-let mockAssistantId = "";
+let mockPlatformClient: Record<string, unknown> | null = null;
 
 // ---------------------------------------------------------------------------
 // Module mocks (must precede imports of the module under test)
@@ -48,12 +43,10 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
 }));
 
-mock.module("../config/env.js", () => ({
-  getPlatformAssistantId: () => mockAssistantId,
-}));
-
-mock.module("../providers/managed-proxy/context.js", () => ({
-  resolveManagedProxyContext: async () => mockManagedProxyCtx,
+mock.module("../platform/client.js", () => ({
+  VellumPlatformClient: {
+    create: async () => mockPlatformClient,
+  },
 }));
 
 // ---------------------------------------------------------------------------
@@ -68,6 +61,22 @@ import { PlatformOAuthConnection } from "./platform-connection.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
+function makeMockClient() {
+  return {
+    baseUrl: "https://platform.example.com",
+    assistantApiKey: "sk-test-key",
+    platformAssistantId: "asst-123",
+    fetch: mock(async () => {
+      return new Response(
+        JSON.stringify({
+          results: [{ id: "platform-conn-1", account_label: null }],
+        }),
+        { status: 200 },
+      );
+    }),
+  };
+}
+
 function setupDefaults(): void {
   mockProvider = {
     providerKey: "integration:google",
@@ -100,12 +109,7 @@ function setupDefaults(): void {
       "google-oauth": { mode: "managed" },
     },
   };
-  mockManagedProxyCtx = {
-    enabled: true,
-    platformBaseUrl: "https://platform.example.com",
-    assistantApiKey: "sk-test-key",
-  };
-  mockAssistantId = "asst-123";
+  mockPlatformClient = makeMockClient();
 }
 
 // ---------------------------------------------------------------------------

package/src/oauth/connection-resolver.ts

@@ -1,13 +1,15 @@
-import { getPlatformAssistantId } from "../config/env.js";
 import { getConfig } from "../config/loader.js";
 import { type Services, ServicesSchema } from "../config/schemas/services.js";
-import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
+import { VellumPlatformClient } from "../platform/client.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
+import { getLogger } from "../util/logger.js";
 import { BYOOAuthConnection } from "./byo-connection.js";
 import type { OAuthConnection } from "./connection.js";
 import { getActiveConnection, getProvider } from "./oauth-store.js";
 import { PlatformOAuthConnection } from "./platform-connection.js";
 
+const log = getLogger("connection-resolver");
+
 export interface ResolveOAuthConnectionOptions {
   /** OAuth app client ID — narrows to a specific app when multiple BYO apps
    *  exist for the same provider. */
@@ -46,16 +48,32 @@ export async function resolveOAuthConnection(
   if (managedKey && managedKey in ServicesSchema.shape) {
     const services: Services = getConfig().services;
     if (services[managedKey as keyof Services].mode === "managed") {
-      const ctx = await resolveManagedProxyContext();
-      const assistantId = getPlatformAssistantId();
+      const client = await VellumPlatformClient.create();
+      if (!client || !client.platformAssistantId) {
+        const detail = !client
+          ? "missing platform prerequisites"
+          : "missing assistant ID";
+        throw new Error(
+          `Platform-managed connection for "${providerKey}" cannot be created: ${detail}. ` +
+            `Log in to the Vellum platform or switch to using your own OAuth app.`,
+        );
+      }
+
+      const providerSlug = providerKey.replace(/^integration:/, "");
+
+      const connectionId = await resolvePlatformConnectionId({
+        client,
+        provider: providerSlug,
+        account,
+      });
+
       return new PlatformOAuthConnection({
         id: providerKey,
         providerKey,
         externalId: providerKey,
         accountInfo: account ?? null,
-        assistantId,
-        platformBaseUrl: ctx.platformBaseUrl,
-        apiKey: ctx.assistantApiKey,
+        client,
+        connectionId,
       });
     }
   }
@@ -98,3 +116,70 @@ export async function resolveOAuthConnection(
     accountInfo: conn.accountInfo,
   });
 }
+
+// ---------------------------------------------------------------------------
+// Platform connection ID resolution
+// ---------------------------------------------------------------------------
+
+interface ResolvePlatformConnectionIdOptions {
+  client: VellumPlatformClient;
+  provider: string;
+  account?: string;
+}
+
+/**
+ * Fetch the platform-side connection ID for a managed provider by calling
+ * the List Connections endpoint.
+ */
+async function resolvePlatformConnectionId(
+  options: ResolvePlatformConnectionIdOptions,
+): Promise<string> {
+  const { client, provider, account } = options;
+
+  const params = new URLSearchParams();
+  params.set("provider", provider);
+  params.set("status", "ACTIVE");
+  if (account) {
+    params.set("account_identifier", account);
+  }
+
+  const path = `/v1/assistants/${client.platformAssistantId}/oauth/connections/?${params.toString()}`;
+  const response = await client.fetch(path);
+
+  if (!response.ok) {
+    log.error(
+      { status: response.status, provider },
+      "Failed to list platform OAuth connections",
+    );
+    throw new Error(
+      `Failed to resolve platform connection for "${provider}": HTTP ${response.status}`,
+    );
+  }
+
+  const body = (await response.json()) as {
+    results?: Array<{ id: string; account_label?: string }>;
+  };
+  const connections = body.results ?? [];
+
+  if (connections.length === 0) {
+    throw new Error(
+      `No active platform OAuth connection found for provider "${provider}"` +
+        (account ? ` with account "${account}"` : "") +
+        ". Connect the service on the Vellum platform first.",
+    );
+  }
+
+  if (connections.length > 1 && !account) {
+    log.warn(
+      {
+        provider,
+        count: connections.length,
+        selectedId: connections[0].id,
+      },
+      "Multiple active platform connections found; using the most recently created. " +
+        "Pass an account option to select a specific connection.",
+    );
+  }
+
+  return connections[0].id;
+}

package/src/oauth/platform-connection.test.ts

@@ -1,5 +1,6 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 
+import type { VellumPlatformClient } from "../platform/client.js";
 import { BackendError, VellumError } from "../util/errors.js";
 import {
   CredentialRequiredError,
@@ -7,40 +8,53 @@ import {
   ProviderUnreachableError,
 } from "./platform-connection.js";
 
+function makeMockClient(
+  fetchImpl?: typeof globalThis.fetch,
+): VellumPlatformClient {
+  const mockFetchFn =
+    fetchImpl ??
+    (mock(async () => {
+      return new Response(
+        JSON.stringify({ status: 200, headers: {}, body: null }),
+        { status: 200 },
+      );
+    }) as unknown as typeof globalThis.fetch);
+
+  return {
+    baseUrl: "https://platform.example.com",
+    assistantApiKey: "test-api-key",
+    platformAssistantId: "asst-abc",
+    fetch: mock(async (path: string, init?: RequestInit) => {
+      const url = `https://platform.example.com${path}`;
+      const headers = new Headers(init?.headers);
+      headers.set("Authorization", "Api-Key test-api-key");
+      return mockFetchFn(url, { ...init, headers });
+    }),
+  } as unknown as VellumPlatformClient;
+}
+
 const DEFAULT_OPTIONS = {
   id: "conn-1",
   providerKey: "integration:google",
   externalId: "ext-123",
   accountInfo: "user@example.com",
-  assistantId: "asst-abc",
-  platformBaseUrl: "https://platform.example.com",
-  apiKey: "test-api-key",
+  client: makeMockClient(),
+  connectionId: "platform-conn-123",
 };
 
 describe("PlatformOAuthConnection", () => {
-  let originalFetch: typeof globalThis.fetch;
-
-  beforeEach(() => {
-    originalFetch = globalThis.fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
   test("successful proxied request", async () => {
     const upstreamBody = { messages: [{ id: "msg-1", snippet: "Hello" }] };
 
-    globalThis.fetch = mock(
-      async (url: string | URL | Request, init?: RequestInit) => {
-        expect(url).toBe(
-          "https://platform.example.com/v1/assistants/asst-abc/external-provider-proxy/google/",
+    const client = makeMockClient(
+      mock(async (url: string | URL | Request, init?: RequestInit) => {
+        expect(String(url)).toBe(
+          "https://platform.example.com/v1/assistants/asst-abc/external-provider-proxy/platform-conn-123/",
         );
         expect(init?.method).toBe("POST");
-        expect(init?.headers).toEqual({
-          Authorization: "Api-Key test-api-key",
-          "Content-Type": "application/json",
-        });
+        const headers = new Headers(init?.headers);
+        expect(headers.get("Authorization")).toBe("Api-Key test-api-key");
+        expect(headers.get("Content-Type")).toBe("application/json");
 
         const parsed = JSON.parse(init?.body as string);
         expect(parsed).toEqual({
@@ -61,10 +75,13 @@ describe("PlatformOAuthConnection", () => {
           }),
           { status: 200 },
         );
-      },
-    ) as unknown as typeof globalThis.fetch;
+      }) as unknown as typeof globalThis.fetch,
+    );
 
-    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    const conn = new PlatformOAuthConnection({
+      ...DEFAULT_OPTIONS,
+      client,
+    });
     const result = await conn.request({
       method: "GET",
       path: "/gmail/v1/users/me/messages",
@@ -77,8 +94,8 @@ describe("PlatformOAuthConnection", () => {
   });
 
   test("forwards baseUrl when provided", async () => {
-    globalThis.fetch = mock(
-      async (_url: string | URL | Request, init?: RequestInit) => {
+    const client = makeMockClient(
+      mock(async (_url: string | URL | Request, init?: RequestInit) => {
         const parsed = JSON.parse(init?.body as string);
         expect(parsed.request.baseUrl).toBe(
           "https://www.googleapis.com/calendar/v3",
@@ -88,10 +105,10 @@ describe("PlatformOAuthConnection", () => {
           JSON.stringify({ status: 200, headers: {}, body: {} }),
           { status: 200 },
         );
-      },
-    ) as unknown as typeof globalThis.fetch;
+      }) as unknown as typeof globalThis.fetch,
+    );
 
-    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    const conn = new PlatformOAuthConnection({ ...DEFAULT_OPTIONS, client });
     await conn.request({
       method: "GET",
       path: "/calendars/primary/events",
@@ -100,8 +117,8 @@ describe("PlatformOAuthConnection", () => {
   });
 
   test("omits baseUrl from envelope when not provided", async () => {
-    globalThis.fetch = mock(
-      async (_url: string | URL | Request, init?: RequestInit) => {
+    const client = makeMockClient(
+      mock(async (_url: string | URL | Request, init?: RequestInit) => {
         const parsed = JSON.parse(init?.body as string);
         expect("baseUrl" in parsed.request).toBe(false);
 
@@ -109,10 +126,10 @@ describe("PlatformOAuthConnection", () => {
           JSON.stringify({ status: 200, headers: {}, body: null }),
           { status: 200 },
         );
-      },
-    ) as unknown as typeof globalThis.fetch;
+      }) as unknown as typeof globalThis.fetch,
+    );
 
-    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    const conn = new PlatformOAuthConnection({ ...DEFAULT_OPTIONS, client });
     await conn.request({ method: "GET", path: "/some/path" });
   });
 
@@ -127,22 +144,26 @@ describe("PlatformOAuthConnection", () => {
   });
 
   test("424 response throws CredentialRequiredError", async () => {
-    globalThis.fetch = mock(async () => {
-      return new Response("", { status: 424 });
-    }) as unknown as typeof globalThis.fetch;
+    const client = makeMockClient(
+      mock(
+        async () => new Response("", { status: 424 }),
+      ) as unknown as typeof globalThis.fetch,
+    );
 
-    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    const conn = new PlatformOAuthConnection({ ...DEFAULT_OPTIONS, client });
     await expect(
       conn.request({ method: "GET", path: "/test" }),
     ).rejects.toThrow(CredentialRequiredError);
   });
 
   test("502 response throws ProviderUnreachableError", async () => {
-    globalThis.fetch = mock(async () => {
-      return new Response("", { status: 502 });
-    }) as unknown as typeof globalThis.fetch;
+    const client = makeMockClient(
+      mock(
+        async () => new Response("", { status: 502 }),
+      ) as unknown as typeof globalThis.fetch,
+    );
 
-    const conn = new PlatformOAuthConnection(DEFAULT_OPTIONS);
+    const conn = new PlatformOAuthConnection({ ...DEFAULT_OPTIONS, client });
     await expect(
       conn.request({ method: "GET", path: "/test" }),
     ).rejects.toThrow(ProviderUnreachableError);
@@ -155,36 +176,24 @@ describe("PlatformOAuthConnection", () => {
     );
   });
 
-  test("strips trailing slash from platformBaseUrl to avoid double slashes", async () => {
-    globalThis.fetch = mock(async (url: string | URL | Request) => {
-      expect(String(url)).toBe(
-        "https://platform.example.com/v1/assistants/asst-abc/external-provider-proxy/google/",
-      );
-      return new Response(
-        JSON.stringify({ status: 200, headers: {}, body: null }),
-        { status: 200 },
-      );
-    }) as unknown as typeof globalThis.fetch;
-
-    const conn = new PlatformOAuthConnection({
-      ...DEFAULT_OPTIONS,
-      platformBaseUrl: "https://platform.example.com/",
-    });
-    await conn.request({ method: "GET", path: "/test" });
-  });
-
-  test("strips integration: prefix from providerKey for slug", async () => {
-    globalThis.fetch = mock(async (url: string | URL | Request) => {
-      expect(String(url)).toContain("/external-provider-proxy/slack/");
-      return new Response(
-        JSON.stringify({ status: 200, headers: {}, body: null }),
-        { status: 200 },
-      );
-    }) as unknown as typeof globalThis.fetch;
+  test("uses connectionId in proxy URL regardless of providerKey format", async () => {
+    const client = makeMockClient(
+      mock(async (url: string | URL | Request) => {
+        expect(String(url)).toContain(
+          "/external-provider-proxy/slack-conn-456/",
+        );
+        return new Response(
+          JSON.stringify({ status: 200, headers: {}, body: null }),
+          { status: 200 },
+        );
+      }) as unknown as typeof globalThis.fetch,
+    );
 
     const conn = new PlatformOAuthConnection({
       ...DEFAULT_OPTIONS,
+      client,
       providerKey: "integration:slack",
+      connectionId: "slack-conn-456",
     });
     await conn.request({ method: "GET", path: "/test" });
   });