@vellumai/assistant 0.6.2 → 0.6.4

package/src/__tests__/credential-vault.test.ts

@@ -50,7 +50,15 @@ mock.module("../tools/registry.js", () => ({
 // ---------------------------------------------------------------------------
 
 let mockRefreshOAuth2Token: ReturnType<
-  typeof mock<() => Promise<{ accessToken: string; expiresIn: number }>>
+  typeof mock<
+    (
+      tokenExchangeUrl: string,
+      clientId: string,
+      refreshToken: string,
+      clientSecret?: string,
+      tokenEndpointAuthMethod?: string,
+    ) => Promise<{ accessToken: string; expiresIn: number }>
+  >
 >;
 
 mock.module("../security/oauth2.js", () => {
@@ -74,7 +82,7 @@ const mockConnections = new Map<
   string,
   {
     id: string;
-    providerKey: string;
+    provider: string;
     oauthAppId: string;
     expiresAt: number | null;
   }
@@ -83,7 +91,7 @@ const mockApps = new Map<
   string,
   {
     id: string;
-    providerKey: string;
+    provider: string;
     clientId: string;
     clientSecretCredentialPath: string;
   }
@@ -92,21 +100,22 @@ const mockProviders = new Map<
   string,
   {
     key: string;
-    tokenUrl: string;
+    tokenExchangeUrl: string;
+    refreshUrl?: string | null;
     tokenEndpointAuthMethod?: string;
   }
 >();
 
 let mockDisconnectOAuthProvider: ReturnType<
   typeof mock<
-    (providerKey: string) => Promise<"disconnected" | "not-found" | "error">
+    (provider: string) => Promise<"disconnected" | "not-found" | "error">
   >
 >;
 
 mock.module("../oauth/oauth-store.js", () => {
-  mockDisconnectOAuthProvider = mock((providerKey: string) =>
+  mockDisconnectOAuthProvider = mock((provider: string) =>
     Promise.resolve(
-      mockConnections.has(providerKey)
+      mockConnections.has(provider)
         ? ("disconnected" as const)
         : ("not-found" as const),
     ),
@@ -746,7 +755,7 @@ describe("credential_store tool", () => {
       // Simulate an active OAuth connection for this service
       mockConnections.set("google", {
         id: "conn-gmail",
-        providerKey: "google",
+        provider: "google",
         oauthAppId: "app-gmail",
         expiresAt: Date.now() + 3600_000,
       });
@@ -1303,7 +1312,7 @@ describe("withValidToken refresh deduplication", () => {
    * Helper: set up a service with an access token, refresh token, and
    * mock DB data so that token refresh can proceed through doRefresh().
    *
-   * OAuth-specific fields (tokenUrl, clientId, expiresAt) are now stored
+   * OAuth-specific fields (tokenExchangeUrl, clientId, expiresAt) are now stored
    * in the SQLite oauth-store. The mock maps simulate the DB layer.
    */
   async function setupService(
@@ -1324,17 +1333,18 @@ describe("withValidToken refresh deduplication", () => {
     );
     mockProviders.set(service, {
       key: service,
-      tokenUrl: "https://oauth.example.com/token",
+      tokenExchangeUrl: "https://oauth.example.com/token",
+      refreshUrl: null,
     });
     mockApps.set(appId, {
       id: appId,
-      providerKey: service,
+      provider: service,
       clientId: "test-client-id",
       clientSecretCredentialPath: `oauth_app/${appId}/client_secret`,
     });
     mockConnections.set(service, {
       id: connId,
-      providerKey: service,
+      provider: service,
       oauthAppId: appId,
       expiresAt: opts?.expired
         ? Date.now() - 60_000 // expired 1 minute ago
@@ -1428,7 +1438,7 @@ describe("withValidToken refresh deduplication", () => {
     let refreshCallCount = 0;
     mockRefreshOAuth2Token.mockImplementation(() => {
       refreshCallCount++;
-      // Both services use the same tokenUrl in this test, so we track by
+      // Both services use the same tokenExchangeUrl in this test, so we track by
       // call order to return the correct deferred promise.
       if (refreshCallCount === 1) return gmailPromise;
       return slackPromise;
@@ -1527,4 +1537,133 @@ describe("withValidToken refresh deduplication", () => {
     // Only one actual refresh attempt
     expect(mockRefreshOAuth2Token).toHaveBeenCalledTimes(1);
   });
+
+  // -----------------------------------------------------------------------
+  // refreshUrl resolution — provider.refreshUrl with fallback to tokenExchangeUrl
+  // -----------------------------------------------------------------------
+  describe("refreshUrl resolution", () => {
+    test("uses provider.refreshUrl when set", async () => {
+      await setupService("google");
+      mockProviders.get("google")!.refreshUrl =
+        "https://refresh.example.com/token";
+
+      mockRefreshOAuth2Token.mockImplementation(() =>
+        Promise.resolve({
+          accessToken: "new-token-from-refresh-url",
+          expiresIn: 3600,
+        }),
+      );
+
+      const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
+
+      const callback = async (token: string) => {
+        if (token === "old-access-token") throw err401;
+        return `result-with-${token}`;
+      };
+
+      const result = await withValidToken("google", callback);
+
+      expect(result).toBe("result-with-new-token-from-refresh-url");
+      expect(mockRefreshOAuth2Token).toHaveBeenCalledTimes(1);
+      // Assert the refresh endpoint passed in is provider.refreshUrl, not
+      // the tokenExchangeUrl fallback.
+      expect(mockRefreshOAuth2Token.mock.calls[0]?.[0]).toBe(
+        "https://refresh.example.com/token",
+      );
+    });
+
+    test("falls back to provider.tokenExchangeUrl when refreshUrl is null", async () => {
+      // setupService sets refreshUrl: null by default — this exercises the
+      // fallback path explicitly.
+      await setupService("google");
+      expect(mockProviders.get("google")!.refreshUrl).toBeNull();
+
+      mockRefreshOAuth2Token.mockImplementation(() =>
+        Promise.resolve({
+          accessToken: "new-token-from-token-exchange-url",
+          expiresIn: 3600,
+        }),
+      );
+
+      const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
+
+      const callback = async (token: string) => {
+        if (token === "old-access-token") throw err401;
+        return `result-with-${token}`;
+      };
+
+      const result = await withValidToken("google", callback);
+
+      expect(result).toBe("result-with-new-token-from-token-exchange-url");
+      expect(mockRefreshOAuth2Token).toHaveBeenCalledTimes(1);
+      // Assert the refresh endpoint falls back to tokenExchangeUrl.
+      expect(mockRefreshOAuth2Token.mock.calls[0]?.[0]).toBe(
+        "https://oauth.example.com/token",
+      );
+    });
+
+    test("falls back to provider.tokenExchangeUrl when refreshUrl is undefined", async () => {
+      await setupService("google");
+      // Delete the refreshUrl field entirely so the property is `undefined`
+      // rather than `null`. Both representations of "not set" must produce
+      // the fallback behavior.
+      delete mockProviders.get("google")!.refreshUrl;
+      expect(mockProviders.get("google")!.refreshUrl).toBeUndefined();
+
+      mockRefreshOAuth2Token.mockImplementation(() =>
+        Promise.resolve({
+          accessToken: "new-token-from-token-exchange-url",
+          expiresIn: 3600,
+        }),
+      );
+
+      const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
+
+      const callback = async (token: string) => {
+        if (token === "old-access-token") throw err401;
+        return `result-with-${token}`;
+      };
+
+      const result = await withValidToken("google", callback);
+
+      expect(result).toBe("result-with-new-token-from-token-exchange-url");
+      expect(mockRefreshOAuth2Token).toHaveBeenCalledTimes(1);
+      // Assert the refresh endpoint falls back to tokenExchangeUrl.
+      expect(mockRefreshOAuth2Token.mock.calls[0]?.[0]).toBe(
+        "https://oauth.example.com/token",
+      );
+    });
+
+    test("falls back to provider.tokenExchangeUrl when refreshUrl is empty string", async () => {
+      // Platform's Python `oauth_app.refresh_url or oauth_app.token_exchange_url`
+      // treats an empty string as unset. We use `||` (not `??`) so empty
+      // strings follow the same fallback path and never resolve to an empty
+      // endpoint.
+      await setupService("google");
+      mockProviders.get("google")!.refreshUrl = "";
+
+      mockRefreshOAuth2Token.mockImplementation(() =>
+        Promise.resolve({
+          accessToken: "new-token-from-token-exchange-url",
+          expiresIn: 3600,
+        }),
+      );
+
+      const err401 = Object.assign(new Error("Unauthorized"), { status: 401 });
+
+      const callback = async (token: string) => {
+        if (token === "old-access-token") throw err401;
+        return `result-with-${token}`;
+      };
+
+      const result = await withValidToken("google", callback);
+
+      expect(result).toBe("result-with-new-token-from-token-exchange-url");
+      expect(mockRefreshOAuth2Token).toHaveBeenCalledTimes(1);
+      // Assert the refresh endpoint falls back to tokenExchangeUrl — NOT "".
+      expect(mockRefreshOAuth2Token.mock.calls[0]?.[0]).toBe(
+        "https://oauth.example.com/token",
+      );
+    });
+  });
 });

package/src/__tests__/credentials-cli.test.ts

@@ -20,40 +20,64 @@ function nextUUID(): string {
 }
 
 // ---------------------------------------------------------------------------
-// Mock secure-keys
+// Mock daemon-credential-client
+//
+// The credentials CLI routes secret read/write through the daemon HTTP API
+// (see src/cli/lib/daemon-credential-client.ts). Mocking the daemon client
+// directly is the cleanest way to isolate the CLI from the real daemon or a
+// running daemon on localhost (which would otherwise be reached via the HTTP
+// healthz fallback in daemon-credential-client).
 // ---------------------------------------------------------------------------
 
-mock.module("../security/secure-keys.js", () => ({
-  setSecureKeyAsync: async (
-    account: string,
+function normalizeCredentialAccount(
+  type: string,
+  name: string,
+): string {
+  if (type !== "credential") return name;
+  if (name.startsWith("credential/")) return name;
+  const colonIdx = name.lastIndexOf(":");
+  if (colonIdx > 0 && colonIdx < name.length - 1) {
+    return `credential/${name.slice(0, colonIdx)}/${name.slice(colonIdx + 1)}`;
+  }
+  return name;
+}
+
+mock.module("../cli/lib/daemon-credential-client.js", () => ({
+  setSecureKeyViaDaemon: async (
+    type: string,
+    name: string,
     value: string,
   ): Promise<boolean> => {
-    secureKeyStore.set(account, value);
+    secureKeyStore.set(normalizeCredentialAccount(type, name), value);
     return true;
   },
-  deleteSecureKeyAsync: async (
-    account: string,
+  deleteSecureKeyViaDaemon: async (
+    type: string,
+    name: string,
   ): Promise<"deleted" | "not-found" | "error"> => {
-    if (secureKeyStore.has(account)) {
-      secureKeyStore.delete(account);
+    const key = normalizeCredentialAccount(type, name);
+    if (secureKeyStore.has(key)) {
+      secureKeyStore.delete(key);
       return "deleted";
     }
     return "not-found";
   },
-  listSecureKeysAsync: async () => ({
-    accounts: [...secureKeyStore.keys()],
-    unreachable: false,
-  }),
-  getSecureKeyAsync: async (account: string): Promise<string | undefined> => {
+  getSecureKeyViaDaemon: async (
+    account: string,
+  ): Promise<string | undefined> => {
     return secureKeyStore.get(account);
   },
-  getSecureKeyResultAsync: async (
+  getSecureKeyResultViaDaemon: async (
     account: string,
   ): Promise<{ value: string | undefined; unreachable: boolean }> => ({
     value: secureKeyStore.get(account),
     unreachable: mockBrokerUnreachable,
   }),
-  _resetBackend: (): void => {},
+  getProviderKeyViaDaemon: async (
+    provider: string,
+  ): Promise<string | undefined> => {
+    return secureKeyStore.get(provider);
+  },
 }));
 
 // ---------------------------------------------------------------------------
@@ -148,9 +172,9 @@ let disconnectOAuthProviderResult: "disconnected" | "not-found" | "error" =
 
 mock.module("../oauth/oauth-store.js", () => ({
   disconnectOAuthProvider: async (
-    providerKey: string,
+    provider: string,
   ): Promise<"disconnected" | "not-found" | "error"> => {
-    disconnectOAuthProviderCalls.push(providerKey);
+    disconnectOAuthProviderCalls.push(provider);
     return disconnectOAuthProviderResult;
   },
   getConnectionByProvider: (): undefined => undefined,

package/src/__tests__/cross-provider-web-search.test.ts

@@ -89,7 +89,8 @@ function webSearchResultOnlyMessage(): Message[] {
 // Mock OpenAI SDK
 // ---------------------------------------------------------------------------
 
-let lastOpenAIParams: Record<string, unknown> | null = null;
+let lastOpenAIResponsesParams: Record<string, unknown> | null = null;
+let lastOpenAIChatParams: Record<string, unknown> | null = null;
 
 mock.module("openai", () => {
   class FakeAPIError extends Error {
@@ -110,7 +111,7 @@ mock.module("openai", () => {
       chat = {
         completions: {
           create: (params: Record<string, unknown>) => {
-            lastOpenAIParams = JSON.parse(JSON.stringify(params));
+            lastOpenAIChatParams = JSON.parse(JSON.stringify(params));
             return (async function* () {
               yield {
                 choices: [
@@ -126,6 +127,28 @@ mock.module("openai", () => {
           },
         },
       };
+      responses = {
+        stream: (params: Record<string, unknown>) => {
+          lastOpenAIResponsesParams = JSON.parse(JSON.stringify(params));
+          return (async function* () {
+            yield {
+              type: "response.output_text.delta",
+              delta: "OK",
+            };
+            yield {
+              type: "response.completed",
+              response: {
+                model: "gpt-4o",
+                status: "completed",
+                usage: {
+                  input_tokens: 10,
+                  output_tokens: 5,
+                },
+              },
+            };
+          })();
+        },
+      };
     },
   };
 });
@@ -172,60 +195,137 @@ mock.module("@google/genai", () => {
 
 // Import providers after mocking
 import { GeminiProvider } from "../providers/gemini/client.js";
-import { OpenAIProvider } from "../providers/openai/client.js";
+import {
+  OpenAIChatCompletionsProvider,
+  OpenAIResponsesProvider,
+} from "../providers/openai/client.js";
 
 // ---------------------------------------------------------------------------
-// OpenAI provider tests
+// OpenAI Responses API provider tests
 // ---------------------------------------------------------------------------
 
-describe("Cross-Provider Web Search — OpenAI", () => {
+describe("Cross-Provider Web Search — OpenAI (Responses API)", () => {
   beforeEach(() => {
-    lastOpenAIParams = null;
+    lastOpenAIResponsesParams = null;
   });
 
-  test("degrades server_tool_use in assistant message to text placeholder", async () => {
-    const provider = new OpenAIProvider("sk-test", "gpt-4o");
+  test("degrades server_tool_use in assistant message to text placeholder in Responses input", async () => {
+    const provider = new OpenAIResponsesProvider("sk-test", "gpt-4o");
     await provider.sendMessage(webSearchConversation());
 
-    const messages = lastOpenAIParams!.messages as Array<{
-      role: string;
-      content: unknown;
+    const input = lastOpenAIResponsesParams!.input as Array<{
+      type: string;
+      role?: string;
+      content?: Array<{ type: string; text?: string }>;
     }>;
 
-    const assistantMsg = messages.find((m) => m.role === "assistant");
-    expect(assistantMsg).toBeDefined();
-    expect(assistantMsg!.content).toContain("[Web search: web_search]");
-    expect(assistantMsg!.content).toContain("Here are the results.");
+    const assistantItems = input.filter(
+      (item) => item.type === "message" && item.role === "assistant",
+    );
+    const hasWebSearchPlaceholder = assistantItems.some((item) =>
+      item.content?.some(
+        (part) =>
+          part.type === "output_text" &&
+          part.text?.includes("[Web search: web_search]"),
+      ),
+    );
+    expect(hasWebSearchPlaceholder).toBe(true);
+
+    const hasResultsText = assistantItems.some((item) =>
+      item.content?.some(
+        (part) =>
+          part.type === "output_text" &&
+          part.text?.includes("Here are the results."),
+      ),
+    );
+    expect(hasResultsText).toBe(true);
   });
 
-  test("degrades web_search_tool_result in user message to text placeholder", async () => {
-    const provider = new OpenAIProvider("sk-test", "gpt-4o");
+  test("degrades web_search_tool_result in user message to text placeholder in Responses input", async () => {
+    const provider = new OpenAIResponsesProvider("sk-test", "gpt-4o");
     await provider.sendMessage(webSearchConversation());
 
-    const messages = lastOpenAIParams!.messages as Array<{
-      role: string;
-      content: unknown;
+    const input = lastOpenAIResponsesParams!.input as Array<{
+      type: string;
+      role?: string;
+      content?: Array<{ type: string; text?: string }>;
     }>;
 
-    const userMsgs = messages.filter((m) => m.role === "user");
-    const hasWebSearchResult = userMsgs.some((m) => {
-      if (typeof m.content === "string") return false;
-      if (Array.isArray(m.content)) {
-        return (m.content as Array<{ type: string; text?: string }>).some(
-          (part) =>
-            part.type === "text" && part.text === "[Web search results]",
-        );
-      }
-      return false;
-    });
+    const userItems = input.filter(
+      (item) => item.type === "message" && item.role === "user",
+    );
+    const hasWebSearchResult = userItems.some((item) =>
+      item.content?.some(
+        (part) =>
+          part.type === "input_text" && part.text === "[Web search results]",
+      ),
+    );
     expect(hasWebSearchResult).toBe(true);
   });
 
   test("handles message containing only web_search_tool_result", async () => {
-    const provider = new OpenAIProvider("sk-test", "gpt-4o");
+    const provider = new OpenAIResponsesProvider("sk-test", "gpt-4o");
     await provider.sendMessage(webSearchResultOnlyMessage());
 
-    const messages = lastOpenAIParams!.messages as Array<{
+    const input = lastOpenAIResponsesParams!.input as Array<{
+      type: string;
+      role?: string;
+      content?: Array<{ type: string; text?: string }>;
+    }>;
+
+    const assistantItems = input.filter(
+      (item) => item.type === "message" && item.role === "assistant",
+    );
+    const hasWebSearchPlaceholder = assistantItems.some((item) =>
+      item.content?.some(
+        (part) =>
+          part.type === "output_text" &&
+          part.text?.includes("[Web search: web_search]"),
+      ),
+    );
+    expect(hasWebSearchPlaceholder).toBe(true);
+
+    const userItems = input.filter(
+      (item) => item.type === "message" && item.role === "user",
+    );
+    const hasWebSearchResult = userItems.some((item) =>
+      item.content?.some(
+        (part) =>
+          part.type === "input_text" && part.text === "[Web search results]",
+      ),
+    );
+    expect(hasWebSearchResult).toBe(true);
+  });
+
+  test("does not produce function_call items for server_tool_use blocks", async () => {
+    const provider = new OpenAIResponsesProvider("sk-test", "gpt-4o");
+    await provider.sendMessage(webSearchConversation());
+
+    const input = lastOpenAIResponsesParams!.input as Array<{
+      type: string;
+    }>;
+
+    const functionCallItems = input.filter(
+      (item) => item.type === "function_call",
+    );
+    expect(functionCallItems).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// OpenAI Chat Completions compatibility provider tests
+// ---------------------------------------------------------------------------
+
+describe("Cross-Provider Web Search — OpenAI Chat Completions (compatibility)", () => {
+  beforeEach(() => {
+    lastOpenAIChatParams = null;
+  });
+
+  test("degrades server_tool_use in assistant message to text placeholder", async () => {
+    const provider = new OpenAIChatCompletionsProvider("sk-test", "gpt-4o");
+    await provider.sendMessage(webSearchConversation());
+
+    const messages = lastOpenAIChatParams!.messages as Array<{
       role: string;
       content: unknown;
     }>;
@@ -233,6 +333,17 @@ describe("Cross-Provider Web Search — OpenAI", () => {
     const assistantMsg = messages.find((m) => m.role === "assistant");
     expect(assistantMsg).toBeDefined();
     expect(assistantMsg!.content).toContain("[Web search: web_search]");
+    expect(assistantMsg!.content).toContain("Here are the results.");
+  });
+
+  test("degrades web_search_tool_result in user message to text placeholder", async () => {
+    const provider = new OpenAIChatCompletionsProvider("sk-test", "gpt-4o");
+    await provider.sendMessage(webSearchConversation());
+
+    const messages = lastOpenAIChatParams!.messages as Array<{
+      role: string;
+      content: unknown;
+    }>;
 
     const userMsgs = messages.filter((m) => m.role === "user");
     const hasWebSearchResult = userMsgs.some((m) => {
@@ -249,10 +360,10 @@ describe("Cross-Provider Web Search — OpenAI", () => {
   });
 
   test("does not produce tool_calls for server_tool_use blocks", async () => {
-    const provider = new OpenAIProvider("sk-test", "gpt-4o");
+    const provider = new OpenAIChatCompletionsProvider("sk-test", "gpt-4o");
     await provider.sendMessage(webSearchConversation());
 
-    const messages = lastOpenAIParams!.messages as Array<{
+    const messages = lastOpenAIChatParams!.messages as Array<{
       role: string;
       tool_calls?: unknown[];
     }>;

package/src/__tests__/date-context.test.ts

@@ -115,7 +115,7 @@ describe("formatTurnTimestamp", () => {
       timeZone: "America/Chicago",
     });
     expect(result).toBe(
-      "2026-04-02 (Thu) 01:52:33 -05:00 (America/Chicago)",
+      "2026-04-02 (Thursday) 01:52:33 -05:00 (America/Chicago)",
     );
   });
 
@@ -124,7 +124,7 @@ describe("formatTurnTimestamp", () => {
       nowMs: THU_APR_02_0652,
       hostTimeZone: "UTC",
     });
-    expect(result).toBe("2026-04-02 (Thu) 06:52:33 +00:00 (UTC)");
+    expect(result).toBe("2026-04-02 (Thursday) 06:52:33 +00:00 (UTC)");
   });
 
   test("handles user timezone override", () => {
@@ -133,7 +133,7 @@ describe("formatTurnTimestamp", () => {
       hostTimeZone: "UTC",
       userTimeZone: "Asia/Tokyo",
     });
-    expect(result).toBe("2026-04-02 (Thu) 15:52:33 +09:00 (Asia/Tokyo)");
+    expect(result).toBe("2026-04-02 (Thursday) 15:52:33 +09:00 (Asia/Tokyo)");
   });
 
   test("handles DST correctly", () => {
@@ -144,7 +144,7 @@ describe("formatTurnTimestamp", () => {
       timeZone: "America/New_York",
     });
     expect(result).toBe(
-      "2026-07-01 (Wed) 08:00:30 -04:00 (America/New_York)",
+      "2026-07-01 (Wednesday) 08:00:30 -04:00 (America/New_York)",
     );
   });
 

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -31,6 +31,7 @@ mock.module("../config/env.js", () => ({
 // Imports (after mocks)
 // ---------------------------------------------------------------------------
 
+import type { TwilioRelaySpeechConfig } from "../calls/twilio-routes.js";
 import { generateTwiML } from "../calls/twilio-routes.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
@@ -100,9 +101,14 @@ describe("Channel verification reply templates", () => {
 describe("TwiML parameter propagation", () => {
   const defaultProfile = {
     language: "en-US",
-    transcriptionProvider: "deepgram",
     ttsProvider: "google",
     voice: "en-US-Standard-A",
+  };
+
+  const defaultSpeechConfig: TwilioRelaySpeechConfig = {
+    transcriptionProvider: "deepgram",
+    speechModel: undefined,
+    hints: undefined,
     interruptSensitivity: "low",
   };
 
@@ -112,6 +118,7 @@ describe("TwiML parameter propagation", () => {
       "wss://example.com/v1/calls/relay",
       null,
       defaultProfile,
+      defaultSpeechConfig,
       undefined,
       { verificationSessionId: "gv-session-456" },
     );
@@ -126,6 +133,7 @@ describe("TwiML parameter propagation", () => {
       "wss://example.com/v1/calls/relay",
       null,
       defaultProfile,
+      defaultSpeechConfig,
     );
     expect(twiml).not.toContain("<Parameter");
   });
@@ -136,6 +144,7 @@ describe("TwiML parameter propagation", () => {
       "wss://example.com/v1/calls/relay",
       null,
       defaultProfile,
+      defaultSpeechConfig,
       "token123",
       undefined,
     );