@vellumai/assistant 0.11.1-dev.202608032226.351a4e2 → 0.11.1-dev.202608040007.969b6ee

package/openapi.yaml

@@ -10711,6 +10711,11 @@ paths:
                     type: number
                   updatedAt:
                     type: number
+                  workspacePath:
+                    anyOf:
+                      - type: string
+                      - type: "null"
+                    description: Workspace-relative file this document is bound to, or null
                 required:
                   - success
                   - surfaceId
@@ -10720,6 +10725,7 @@ paths:
                   - wordCount
                   - createdAt
                   - updatedAt
+                  - workspacePath
                 additionalProperties: false
   /v1/documents/{id}/comments:
     get:
@@ -11137,6 +11143,74 @@ paths:
               schema:
                 type: string
                 format: binary
+  /v1/documents/for-workspace-file:
+    post:
+      operationId: documents_forworkspacefile_post
+      summary: Get or create the document for a workspace markdown file
+      description:
+        "Return the document bound to a workspace markdown file, creating it on first open. The file is the source
+        of truth at open time: stored content that has drifted from the file is refreshed from disk before the document
+        is returned."
+      tags:
+        - documents
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                path:
+                  type: string
+                  description: Workspace-relative path to a .md/.markdown file
+                conversationId:
+                  type: string
+                  description: Conversation the document is opened from
+              required:
+                - path
+                - conversationId
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  success:
+                    type: boolean
+                  surfaceId:
+                    type: string
+                  conversationId:
+                    type: string
+                  title:
+                    type: string
+                  content:
+                    type: string
+                  wordCount:
+                    type: number
+                  createdAt:
+                    type: number
+                  updatedAt:
+                    type: number
+                  workspacePath:
+                    anyOf:
+                      - type: string
+                      - type: "null"
+                    description: Workspace-relative file this document is bound to, or null
+                required:
+                  - success
+                  - surfaceId
+                  - conversationId
+                  - title
+                  - content
+                  - wordCount
+                  - createdAt
+                  - updatedAt
+                  - workspacePath
+                additionalProperties: false
+        "422":
+          description: Path is not a markdown file
   /v1/domain/register:
     post:
       operationId: domain_register_post
@@ -14679,8 +14753,9 @@ paths:
       summary: Create a provider connection
       description:
         Create a new named provider connection. When auth is omitted it is derived from the provider (keyless
-        providers get none, vellum gets platform, everything else needs credential for api_key auth). Fails with 409 if
-        a connection with this name already exists.
+        providers get none, vellum gets platform, everything else needs credential for api_key auth). An explicit auth
+        object must agree with the provider; platform auth belongs to vellum and only to vellum. Fails with 409 if a
+        connection with this name already exists.
       tags:
         - inference
       requestBody:
@@ -14789,8 +14864,9 @@ paths:
       summary: Update a provider connection
       description:
         Update an existing connection. Cannot rename or change the provider. Omitting auth keeps the stored auth;
-        passing credential alone rotates the key via provider-derived api_key auth. For the Vellum-managed connection
-        (vellum) the auth is locked to platform; label remains editable.
+        passing credential alone rotates the key via provider-derived api_key auth. An explicit auth object must agree
+        with the connection's provider; platform auth belongs to vellum and only to vellum. For the Vellum-managed
+        connection (vellum) the auth is locked to platform; label remains editable.
       tags:
         - inference
       parameters:
@@ -19763,6 +19839,13 @@ paths:
                     Client OS surface ("web" | "ios" | "macos" | "android"), reported separately from `interface`. Drives the
                     per-turn `client_os` context only; does not affect transport/host-proxy capabilities.
                   type: string
+                visibleAppId:
+                  description:
+                    'Id of the app the client currently has open on screen (app viewer or the app-editing split). Drives the
+                    per-turn `visible_app:` context line so the assistant can resolve "the app" to what the user is
+                    looking at. View state only: it never affects transport, routing, or tool gating, and is omitted
+                    whenever no app is in view.'
+                  type: string
                 clientMessageId:
                   type: string
                   description:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.1-dev.202608032226.351a4e2",
+  "version": "0.11.1-dev.202608040007.969b6ee",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/byok-default-profile-ensure.test.ts

@@ -1092,4 +1092,47 @@ describe("ensureByokDefaultProfiles", () => {
 
     expect(readFileSync(configPath(), "utf-8")).toBe(before);
   });
+
+  // The hatch wrote each copy's model by resolving the cost profile's intent
+  // at hatch time. These are the ids that resolved per provider, pinned as
+  // literals rather than derived from the template: a test that materializes
+  // the template agrees with itself no matter which intent the template names,
+  // and so cannot catch a template whose model comparison has drifted off what
+  // is on disk.
+  test.each([
+    ["openrouter", "anthropic/claude-haiku-4.5"],
+    ["gemini", "gemini-3.1-flash-lite"],
+    ["openai", "gpt-5.6-luna"],
+  ] as const)(
+    "an unedited %s cost copy still converts",
+    (provider, hatchModel) => {
+      writeConfig({
+        llm: {
+          defaultProvider: { provider },
+          activeProfile: "custom-cost-optimized",
+          profiles: {
+            "custom-cost-optimized": {
+              ...(hatchBody("cost-optimized", provider) as Record<
+                string,
+                unknown
+              >),
+              model: hatchModel,
+            },
+            "custom-balanced": hatchBody("balanced", provider),
+            "custom-quality-optimized": hatchBody(
+              "quality-optimized",
+              provider,
+            ),
+          },
+        },
+      });
+
+      ensureByokDefaultProfiles(workspaceDir);
+
+      expect(profiles()["custom-cost-optimized"]).toBeUndefined();
+      expect(profiles()["cost-optimized"]).toBeUndefined();
+      expect(llm().activeProfile).toBe("cost-optimized");
+      expectSecondRunNoop();
+    },
+  );
 });

package/src/__tests__/compaction-events.test.ts

@@ -7,6 +7,10 @@
  * turn. The `context_compacted` event is the single source of truth for the
  * indicator — the paired `usage_update` intentionally omits
  * `contextWindowTokens` to avoid a redundant SwiftUI invalidation.
+ *
+ * Also covers the `context_window_usage` push, which carries the provider
+ * tokenizer's post-compaction count so the web indicator matches the numbers
+ * on the `/compact` result card.
  */
 import { describe, expect, mock, test } from "bun:test";
 
@@ -218,7 +222,8 @@ import { Conversation } from "../daemon/conversation.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeProvider() {
+function makeProvider(counts?: number[]) {
+  const pending = counts ? [...counts] : null;
   return {
     name: "mock-provider",
     async sendMessage(): Promise<ProviderResponse> {
@@ -229,16 +234,20 @@ function makeProvider() {
         stopReason: "end_turn",
       };
     },
+    // Present only when the test supplies counts, so the other cases keep
+    // exercising the local-estimate fallback.
+    ...(pending ? { countInputTokens: async () => pending.shift() ?? 0 } : {}),
   };
 }
 
 function makeConversation(
   collected: AssistantEvent[],
   id = "conv-compact-events",
+  counts?: number[],
 ): Conversation {
   return new Conversation(
     id,
-    makeProvider(),
+    makeProvider(counts),
     "system prompt",
     (msg) => {
       collected.push(msg);
@@ -383,6 +392,134 @@ describe("forceCompact event emission", () => {
   });
 });
 
+describe("forceCompact context-window usage push", () => {
+  test("pushes the post-compaction tokenizer count the result card reports", async () => {
+    const collected: AssistantEvent[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: true,
+      // Estimate-based figures the compaction pipeline records internally.
+      // The user-facing numbers come from the provider tokenizer instead.
+      previousEstimatedInputTokens: 43_000,
+      estimatedInputTokens: 12_000,
+      maxInputTokens: 200_000,
+      thresholdTokens: 160_000,
+      compactedMessages: 10,
+      compactedPersistedMessages: 5,
+      summaryCalls: 1,
+      summaryInputTokens: 500,
+      summaryOutputTokens: 200,
+      summaryModel: "test-model",
+      summaryText: "summary text",
+    };
+
+    const conversation = makeConversation(
+      collected,
+      "conv-compact-usage",
+      [56_000, 18_000],
+    );
+    const result = await conversation.forceCompact();
+
+    expect(result.previousEstimatedInputTokens).toBe(56_000);
+    expect(result.estimatedInputTokens).toBe(18_000);
+
+    const usage = collected.filter((m) => m.type === "context_window_usage");
+    expect(usage.length).toBe(1);
+    const usageEvent = usage[0] as Extract<
+      AssistantEvent,
+      { type: "context_window_usage" }
+    >;
+    expect(usageEvent.conversationId).toBe("conv-compact-usage");
+    // Same figures the `/compact` card renders, so the indicator and the card
+    // cannot disagree.
+    expect(usageEvent.tokens).toBe(result.estimatedInputTokens);
+    expect(usageEvent.maxTokens).toBe(200_000);
+  });
+
+  test("pushes to the caller's sink when the conversation's own sender is dead", async () => {
+    // A `/compact` draining behind an interactive turn: `process-message.ts`
+    // resets `sendToClient` to a no-op in its `finally`, while the queued item
+    // still carries the live sink its result card streams on. The push has to
+    // follow the card, not the dead sender.
+    const stranded: AssistantEvent[] = [];
+    const cardSink: AssistantEvent[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: true,
+      previousEstimatedInputTokens: 43_000,
+      estimatedInputTokens: 12_000,
+      maxInputTokens: 200_000,
+      thresholdTokens: 160_000,
+      compactedMessages: 10,
+      compactedPersistedMessages: 5,
+      summaryCalls: 1,
+      summaryInputTokens: 500,
+      summaryOutputTokens: 200,
+      summaryModel: "test-model",
+      summaryText: "summary text",
+    };
+
+    const conversation = makeConversation(
+      stranded,
+      "conv-compact-dead-sender",
+      [56_000, 18_000],
+    );
+    conversation.updateClient(() => {}, true);
+
+    const result = await conversation.forceCompact((msg) => cardSink.push(msg));
+
+    const usage = cardSink.filter((m) => m.type === "context_window_usage");
+    expect(usage.length).toBe(1);
+    expect(
+      (usage[0] as Extract<AssistantEvent, { type: "context_window_usage" }>)
+        .tokens,
+    ).toBe(result.estimatedInputTokens);
+    expect(
+      stranded.filter((m) => m.type === "context_window_usage").length,
+    ).toBe(0);
+  });
+
+  test("pushes the current count when there was nothing to compact", async () => {
+    const collected: AssistantEvent[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: false,
+      previousEstimatedInputTokens: 0,
+      estimatedInputTokens: 0,
+      maxInputTokens: 200_000,
+      thresholdTokens: 160_000,
+      compactedMessages: 0,
+      compactedPersistedMessages: 0,
+      summaryCalls: 0,
+      summaryInputTokens: 0,
+      summaryOutputTokens: 0,
+      summaryModel: "",
+      summaryText: "",
+    };
+
+    const conversation = makeConversation(
+      collected,
+      "conv-compact-usage-noop",
+      // A no-op re-counts nothing, so the single count stands as before and
+      // after.
+      [56_000],
+    );
+    const result = await conversation.forceCompact();
+
+    expect(result.previousEstimatedInputTokens).toBe(56_000);
+    expect(result.estimatedInputTokens).toBe(56_000);
+
+    const usage = collected.filter((m) => m.type === "context_window_usage");
+    expect(usage.length).toBe(1);
+    const usageEvent = usage[0] as Extract<
+      AssistantEvent,
+      { type: "context_window_usage" }
+    >;
+    expect(usageEvent.tokens).toBe(56_000);
+    expect(usageEvent.maxTokens).toBe(200_000);
+  });
+});
+
 describe("maybeCompact gate sizing", () => {
   test("default sizing resolves mainAgent's window; wake sizing resolves the wake's call-site window", async () => {
     // The auto-threshold gate derives its trip point from the

package/src/__tests__/config-loader-backfill.test.ts

@@ -864,7 +864,7 @@ describe("loadConfig startup behavior", () => {
     expect(effective["quality-optimized"]?.provider).toBe("openai");
     expect(effective["quality-optimized"]?.model).toBe("gpt-5.4");
     expect(effective["cost-optimized"]?.provider).toBe("openai");
-    expect(effective["cost-optimized"]?.model).toBe("gpt-5.6-luna");
+    expect(effective["cost-optimized"]?.model).toBe("gpt-5.4-nano");
   });
 
   test("off-platform hatch with a provider outside the named matrix columns resolves through the shared BYOK templates", () => {
@@ -1471,7 +1471,7 @@ describe("seedInferenceProfiles BYOK-mode default profiles", () => {
     );
     expect(effective.balanced?.label).toBe("Balanced");
     expect(effective["quality-optimized"]?.label).toBe("Quality");
-    expect(effective["cost-optimized"]?.label).toBe("Speed");
+    expect(effective["cost-optimized"]?.label).toBe("Cost");
     expect("status" in (effective.balanced ?? {})).toBe(false);
     expect("status" in (effective["quality-optimized"] ?? {})).toBe(false);
     expect("status" in (effective["cost-optimized"] ?? {})).toBe(false);
@@ -1741,7 +1741,39 @@ describe("seedInferenceProfiles BYOK-mode default profiles", () => {
     const effective = getEffectiveProfiles(raw.llm.profiles);
     expect(effective.balanced?.label).toBe("Balanced");
     expect(effective["quality-optimized"]?.label).toBe("Quality");
-    expect(effective["cost-optimized"]?.label).toBe("Speed");
+    expect(effective["cost-optimized"]?.label).toBe("Cost");
+  });
+
+  test("a managed key missing from profileOrder lands beside its siblings", () => {
+    // An install that predates a newly shipped managed profile, with a custom
+    // profile already in its order. The new key belongs with the other
+    // managed profiles, not after whatever the user has arranged below them.
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+        profiles: {
+          "my-custom": { source: "user", provider: "anthropic", model: "x" },
+        },
+        profileOrder: [
+          "balanced",
+          "quality-optimized",
+          "cost-optimized",
+          "my-custom",
+        ],
+        activeProfile: "balanced",
+      },
+    });
+
+    mergeDefaultConfigAndSeedInferenceProfiles();
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+
+    expect(raw.llm.profileOrder).toEqual([
+      "balanced",
+      "quality-optimized",
+      "cost-optimized",
+      "latency-optimized",
+      "my-custom",
+    ]);
   });
 
   test("boot leaves legacy bare labels on managed entries untouched", () => {

package/src/__tests__/conversation-agent-loop-fatal-cleanup.test.ts

@@ -215,3 +215,33 @@ describe("runAgentLoopImpl fatal-failure cleanup (ATL-1009)", () => {
     expect(drainQueue).toHaveBeenCalledWith("loop_complete");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Turn-scoped view state
+//
+// The app the client has on screen rides in on a message's transport. Nothing
+// tells the daemon when the user closes it, so leaving the value on the
+// conversation would let a later turn with no fresh client transport (a
+// scheduled wake, a background follow-up) assert the user is looking at an app
+// they closed. This suite reuses the loop harness above because the clear
+// lives in the loop's per-turn teardown.
+// ---------------------------------------------------------------------------
+
+describe("runAgentLoopImpl per-turn view state", () => {
+  test("clears the reported visible app at turn end so a later turn cannot inherit it", async () => {
+    const events: AssistantEvent[] = [];
+    const ctx = makeCtx({
+      visibleAppId: "app-on-screen",
+      commitTurnChanges: mock(
+        async () => {},
+      ) as unknown as Context["commitTurnChanges"],
+    });
+
+    await runAgentLoopImpl(ctx, "background task", "msg-visible-app", (event) =>
+      events.push(event),
+    );
+
+    expect(ctx.visibleAppId).toBeUndefined();
+    expect(ctx.currentTurnVisibleAppId).toBeUndefined();
+  });
+});

package/src/__tests__/conversation-error.test.ts

@@ -777,6 +777,9 @@ describe("classifyConversationError", () => {
       expect(result.code).toBe("PROVIDER_INVALID_KEY");
       expect(result.retryable).toBe(false);
       expect(result.errorCategory).toBe("provider_invalid_key");
+      expect(result.userMessage).toBe(
+        "Your personal Anthropic API key was rejected by Anthropic. Update that key in Settings → Models & Services.",
+      );
     });
 
     it("classifies managed-proxy auth failures as managed credential refresh failures", () => {
@@ -791,12 +794,30 @@ describe("classifyConversationError", () => {
 
       expect(result.code).toBe("MANAGED_KEY_INVALID");
       expect(result.userMessage).toBe(
-        "Couldn't refresh assistant credentials.",
+        "Vellum's managed inference credential was rejected. This isn't a personal provider API key — Vellum provisions this one, so there's nothing to update in Settings.",
       );
       expect(result.retryable).toBe(false);
       expect(result.errorCategory).toBe("managed_key_invalid");
     });
 
+    it("keeps credential-shaped 4xx failures on the request's managed route", () => {
+      providerRoutingSources.anthropic = "user-key";
+      const err = new ProviderError(
+        "Authentication error: invalid API key",
+        "anthropic",
+        400,
+      );
+      err.attachRouteAttribution({ credentialSource: "vellum-managed" });
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("MANAGED_KEY_INVALID");
+      expect(result.errorCategory).toBe("managed_key_invalid");
+      expect(result.userMessage).toBe(
+        "Vellum's managed inference credential was rejected. This isn't a personal provider API key — Vellum provisions this one, so there's nothing to update in Settings.",
+      );
+    });
+
     it("classifies ProviderError 401 with 'invalid x-api-key' message as PROVIDER_INVALID_KEY", () => {
       // Regex-match branch — Anthropic's standard 401 wording.
       const err = new ProviderError(
@@ -814,6 +835,8 @@ describe("classifyConversationError", () => {
       const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_INVALID_KEY");
       expect(result.errorCategory).toBe("provider_invalid_key");
+      expect(result.userMessage).toContain("personal OpenAI API key");
+      expect(result.userMessage).toContain("rejected by OpenAI");
     });
 
     it("includes connection/profile attribution in PROVIDER_INVALID_KEY when provided", () => {
@@ -826,7 +849,84 @@ describe("classifyConversationError", () => {
       expect(result.code).toBe("PROVIDER_INVALID_KEY");
       expect(result.connectionName).toBe("my-anthropic");
       expect(result.profileName).toBe("personal");
-      expect(result.userMessage).toContain("personal");
+      expect(result.userMessage).toBe(
+        'Your personal Anthropic API key for profile "personal" (connection "my-anthropic") was rejected by Anthropic. Update that key in Settings → Models & Services.',
+      );
+    });
+
+    it("uses the request's BYOK attribution when the same provider also has a managed route", () => {
+      providerRoutingSources.anthropic = "managed-proxy";
+      const err = new ProviderError("Unauthorized", "anthropic", 401);
+      err.attachRouteAttribution({
+        credentialSource: "byok",
+        connectionName: "anthropic-personal",
+      });
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_INVALID_KEY");
+      expect(result.connectionName).toBe("anthropic-personal");
+      expect(result.userMessage).toBe(
+        'Your personal Anthropic API key for connection "anthropic-personal" was rejected by Anthropic. Update that key in Settings → Models & Services.',
+      );
+    });
+
+    it("uses the request's managed attribution when the same provider also has a BYOK route", () => {
+      providerRoutingSources.anthropic = "user-key";
+      const err = new ProviderError("Unauthorized", "anthropic", 401);
+      err.attachRouteAttribution({
+        credentialSource: "vellum-managed",
+        connectionName: "vellum",
+      });
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("MANAGED_KEY_INVALID");
+      expect(result.userMessage).toBe(
+        "Vellum's managed inference credential was rejected. This isn't a personal provider API key — Vellum provisions this one, so there's nothing to update in Settings.",
+      );
+    });
+
+    it("uses subscription-specific recovery when the same provider also has a managed route", () => {
+      providerRoutingSources.openai = "managed-proxy";
+      const err = new ProviderError("Unauthorized", "openai", 401, {
+        reason: "invalid_credentials",
+      });
+      err.attachRouteAttribution({
+        credentialSource: "oauth-subscription",
+        connectionName: "chatgpt-subscription",
+      });
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_API");
+      expect(result.errorCategory).toBe("provider_subscription_auth");
+      expect(result.retryable).toBe(false);
+      expect(result.connectionName).toBe("chatgpt-subscription");
+      expect(result.userMessage).toBe(
+        'Your OpenAI subscription login for connection "chatgpt-subscription" was rejected by OpenAI. Reconnect that account in Settings → Models & Services.',
+      );
+    });
+
+    it("explains when a no-auth endpoint rejects an unauthenticated request", () => {
+      providerRoutingSources["openai-compatible"] = "managed-proxy";
+      const err = new ProviderError("Unauthorized", "openai-compatible", 401, {
+        reason: "invalid_credentials",
+      });
+      err.attachRouteAttribution({
+        credentialSource: "no-auth",
+        connectionName: "local-model-server",
+      });
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_API");
+      expect(result.errorCategory).toBe("provider_endpoint_auth_required");
+      expect(result.retryable).toBe(false);
+      expect(result.connectionName).toBe("local-model-server");
+      expect(result.userMessage).toBe(
+        'The OpenAI-compatible endpoint for connection "local-model-server" requires authentication, but that connection is configured without credentials. Configure authentication for that endpoint in Settings → Models & Services.',
+      );
     });
 
     it("classifies direct ProviderError with 402 as provider_billing (non-retryable)", () => {

package/src/__tests__/conversation-options-turn-scoped-transport.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Tests for `withoutTurnScopedTransport`, the guard that keeps per-message view
+ * state out of the durable `conversationOptions` map.
+ *
+ * `getOrCreateConversation` re-applies the stored transport whenever it rebuilds
+ * an evicted or stale conversation. Anything describing what the client had on
+ * screen for one message must be stripped before it is stored, or a rebuild
+ * hours later (a scheduled wake, a background follow-up) would resurrect an app
+ * the user has since closed and tell the model it is on screen.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { withoutTurnScopedTransport } from "../daemon/conversation-store.js";
+import type { ConversationCreateOptions } from "../daemon/handlers/shared.js";
+
+describe("withoutTurnScopedTransport", () => {
+  test("drops the visible app while keeping durable transport fields", () => {
+    const options: ConversationCreateOptions = {
+      transport: {
+        channelId: "vellum",
+        interfaceId: "web",
+        clientOs: "macos",
+        clientTimezone: "America/Denver",
+        visibleAppId: "app-on-screen",
+      },
+    };
+
+    const stored = withoutTurnScopedTransport(options);
+
+    expect(stored.transport?.visibleAppId).toBeUndefined();
+    expect(stored.transport?.clientOs).toBe("macos");
+    expect(stored.transport?.clientTimezone).toBe("America/Denver");
+    expect(stored.transport?.interfaceId).toBe("web");
+  });
+
+  test("does not mutate the caller's options, which still drive this turn", () => {
+    const options: ConversationCreateOptions = {
+      transport: {
+        channelId: "vellum",
+        interfaceId: "web",
+        visibleAppId: "app-on-screen",
+      },
+    };
+
+    withoutTurnScopedTransport(options);
+
+    expect(options.transport?.visibleAppId).toBe("app-on-screen");
+  });
+
+  test("passes options through untouched when there is no app in view", () => {
+    const options: ConversationCreateOptions = {
+      transport: { channelId: "vellum", interfaceId: "web", clientOs: "ios" },
+    };
+
+    expect(withoutTurnScopedTransport(options)).toBe(options);
+  });
+
+  test("passes options through untouched when there is no transport", () => {
+    const options: ConversationCreateOptions = {};
+
+    expect(withoutTurnScopedTransport(options)).toBe(options);
+  });
+});