@vellumai/assistant 0.5.6 → 0.5.8

package/src/__tests__/memory-retrieval.benchmark.test.ts

@@ -197,7 +197,6 @@ describe("Memory retrieval benchmark", () => {
     expect(recall.enabled).toBe(true);
     expect(recall.degraded).toBe(false);
     // Recency search finds conversation-scoped segments
-    expect(recall.recencyHits).toBeGreaterThan(0);
     // Relaxed threshold — guards against severe regressions, not precise benchmarking
     expect(recall.latencyMs).toBeLessThan(500);
   });
@@ -216,7 +215,6 @@ describe("Memory retrieval benchmark", () => {
 
     expect(recall.enabled).toBe(true);
     expect(recall.degraded).toBe(false);
-    expect(recall.recencyHits).toBeGreaterThan(0);
     expect(recall.latencyMs).toBeLessThan(1000);
   });
 
@@ -234,7 +232,6 @@ describe("Memory retrieval benchmark", () => {
 
     expect(recall.enabled).toBe(true);
     expect(recall.degraded).toBe(false);
-    expect(recall.recencyHits).toBeGreaterThan(0);
     expect(recall.latencyMs).toBeLessThan(2000);
   });
 

package/src/__tests__/migration-export-http.test.ts

@@ -527,9 +527,9 @@ describe("integration: existing routes unaffected", () => {
   });
 
   test("GET /v1/health still works (not intercepted by migration routes)", async () => {
-    const { handleHealth } =
+    const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleHealth();
+    const res = handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/migration-import-commit-http.test.ts

@@ -939,9 +939,9 @@ describe("route policy registration", () => {
 
 describe("integration: existing routes unaffected", () => {
   test("GET /v1/health still works", async () => {
-    const { handleHealth } =
+    const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleHealth();
+    const res = handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/migration-import-preflight-http.test.ts

@@ -792,9 +792,9 @@ describe("route policy registration", () => {
 
 describe("integration: existing routes unaffected", () => {
   test("GET /v1/health still works", async () => {
-    const { handleHealth } =
+    const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleHealth();
+    const res = handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/migration-validate-http.test.ts

@@ -684,9 +684,9 @@ describe("route policy registration", () => {
 
 describe("integration: existing routes unaffected", () => {
   test("GET /v1/health still works (not intercepted by migration routes)", async () => {
-    const { handleHealth } =
+    const { handleDetailedHealth } =
       await import("../runtime/routes/identity-routes.js");
-    const res = handleHealth();
+    const res = handleDetailedHealth();
     const body = (await res.json()) as Record<string, unknown>;
 
     expect(res.status).toBe(200);

package/src/__tests__/non-member-access-request.test.ts

@@ -37,11 +37,6 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-// Mock security check to always pass
-mock.module("../security/secret-ingress.js", () => ({
-  checkIngressForSecrets: () => ({ blocked: false }),
-}));
-
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
   getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
@@ -191,7 +186,7 @@ describe("non-member access request notification", () => {
     expect(deliverReplyCalls.length).toBe(1);
     expect(
       (deliverReplyCalls[0].payload as Record<string, unknown>).text,
-    ).toContain("let them know");
+    ).toContain("know you tried talking to me");
   });
 
   test("guardian is notified when a non-member messages and a guardian binding exists", async () => {
@@ -290,7 +285,7 @@ describe("non-member access request notification", () => {
     expect(deliverReplyCalls.length).toBe(1);
     expect(
       (deliverReplyCalls[0].payload as Record<string, unknown>).text,
-    ).toContain("let them know");
+    ).toContain("know you tried talking to me");
 
     // Notification signal was emitted
     expect(emitSignalCalls.length).toBe(1);

package/src/__tests__/notification-decision-fallback.test.ts

@@ -34,6 +34,10 @@ mock.module("../notifications/conversation-candidates.js", () => ({
   serializeCandidatesForPrompt: () => undefined,
 }));
 
+mock.module("../prompts/persona-resolver.js", () => ({
+  resolveGuardianPersona: () => null,
+}));
+
 let configuredProvider: { sendMessage: () => Promise<unknown> } | null = null;
 let extractedToolUse: unknown = null;
 

package/src/__tests__/notification-decision-identity.test.ts

@@ -36,6 +36,10 @@ mock.module("../notifications/conversation-candidates.js", () => ({
   serializeCandidatesForPrompt: () => undefined,
 }));
 
+mock.module("../prompts/persona-resolver.js", () => ({
+  resolveGuardianPersona: () => null,
+}));
+
 // ── Identity context mock ─────────────────────────────────────────────
 
 let mockIdentityContext: string | null = null;

package/src/__tests__/notification-decision-strategy.test.ts

@@ -18,6 +18,7 @@ import {
   hasInviteFlowDirective,
   normalizeForDirectiveMatching,
   sanitizeIdentityField,
+  sanitizeMessagePreview,
 } from "../notifications/copy-composer.js";
 import {
   enforceGuardianCallConversationAffinity,
@@ -596,6 +597,31 @@ describe("notification decision strategy", () => {
     });
   });
 
+  describe("access-request message preview sanitization", () => {
+    test("strips control characters from message previews", () => {
+      expect(sanitizeMessagePreview("Hello\nWorld")).toBe("Hello World");
+      expect(sanitizeMessagePreview("Test\r\nMessage")).toBe("Test Message");
+    });
+
+    test("clamps to 200 characters (not 120)", () => {
+      const longMessage = "A".repeat(250);
+      const result = sanitizeMessagePreview(longMessage);
+      expect(result.length).toBeLessThanOrEqual(201); // 200 + '…'
+      expect(result).toEndWith("…");
+
+      // Verify it allows messages longer than the identity field limit (120)
+      const midMessage = "B".repeat(150);
+      const midResult = sanitizeMessagePreview(midMessage);
+      expect(midResult).toBe(midMessage); // no truncation at 150 chars
+    });
+
+    test("preserves normal messages", () => {
+      expect(sanitizeMessagePreview("Hello, can you help me?")).toBe(
+        "Hello, can you help me?",
+      );
+    });
+  });
+
   describe("access-request identity line builder", () => {
     test("builds voice identity line with caller name and phone", () => {
       const line = buildAccessRequestIdentityLine({
@@ -627,6 +653,51 @@ describe("notification decision strategy", () => {
       expect(line).toContain("requesting access");
     });
 
+    test("uses <@U...> mention format for Slack external IDs", () => {
+      const line = buildAccessRequestIdentityLine({
+        senderIdentifier: "Alice",
+        actorExternalId: "U04BTP01B2S",
+        sourceChannel: "slack",
+      });
+      expect(line).toContain("<@U04BTP01B2S>");
+      expect(line).not.toContain("[U04BTP01B2S]");
+      expect(line).toContain("via slack");
+    });
+
+    test("does not use <@U...> format for non-Slack channels", () => {
+      const line = buildAccessRequestIdentityLine({
+        senderIdentifier: "Alice",
+        actorExternalId: "U04BTP01B2S",
+        sourceChannel: "telegram",
+      });
+      expect(line).toContain("[U04BTP01B2S]");
+      expect(line).not.toContain("<@U04BTP01B2S>");
+    });
+
+    test("does not duplicate Slack mention when senderIdentifier equals raw external ID", () => {
+      // When actorDisplayName and actorUsername are missing, senderIdentifier
+      // falls back to the raw actorExternalId. The identity line should produce
+      // exactly one <@U...> mention, not two.
+      const line = buildAccessRequestIdentityLine({
+        senderIdentifier: "U04BTP01B2S",
+        actorExternalId: "U04BTP01B2S",
+        sourceChannel: "slack",
+      });
+      const mentionCount = (line.match(/<@U04BTP01B2S>/g) || []).length;
+      expect(mentionCount).toBe(1);
+      expect(line).toContain("via slack");
+    });
+
+    test("does not use <@U...> format for non-user-ID external IDs on Slack", () => {
+      const line = buildAccessRequestIdentityLine({
+        senderIdentifier: "Alice",
+        actorExternalId: "someone@example.com",
+        sourceChannel: "slack",
+      });
+      expect(line).not.toContain("<@someone@example.com>");
+      expect(line).toContain("[someone@example.com]");
+    });
+
     test("sanitizes adversarial display names", () => {
       const line = buildAccessRequestIdentityLine({
         senderIdentifier: "Alice",

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

@@ -155,6 +155,10 @@ mock.module("../oauth/oauth-store.js", () => ({
 // Stub out transitive dependencies that token-manager would normally pull in
 mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (account: string) => mockGetSecureKey(account),
+  getSecureKeyResultAsync: async (account: string) => ({
+    value: mockGetSecureKey(account),
+    unreachable: false,
+  }),
   setSecureKeyAsync: async () => true,
   deleteSecureKeyAsync: async (account: string) => {
     if (secureKeyStore.has(account)) {
@@ -163,7 +167,7 @@ mock.module("../security/secure-keys.js", () => ({
     }
     return "not-found" as const;
   },
-  listSecureKeysAsync: async () => [...secureKeyStore.keys()],
+  listSecureKeysAsync: async () => ({ accounts: [...secureKeyStore.keys()], unreachable: false }),
   _resetBackend: () => {},
 }));
 

package/src/__tests__/permission-types.test.ts

@@ -15,6 +15,7 @@ describe("isAllowDecision", () => {
     "always_allow",
     "always_allow_high_risk",
     "temporary_override",
+    "dangerously_skip_permissions",
   ];
 
   for (const decision of allowDecisions) {

package/src/__tests__/provider-commit-message-generator.test.ts

@@ -69,13 +69,9 @@ const mockProvider: Provider = {
 let resolvedProvider: {
   provider: Provider;
   configuredProviderName: string;
-  selectedProviderName: string;
-  usedFallbackPrimary: boolean;
 } | null = {
   provider: mockProvider,
   configuredProviderName: "anthropic",
-  selectedProviderName: "anthropic",
-  usedFallbackPrimary: false,
 };
 
 mock.module("../providers/provider-send-message.js", () => ({
@@ -130,8 +126,6 @@ describe("ProviderCommitMessageGenerator", () => {
     resolvedProvider = {
       provider: mockProvider,
       configuredProviderName: "anthropic",
-      selectedProviderName: "anthropic",
-      usedFallbackPrimary: false,
     };
   });
 
@@ -343,8 +337,6 @@ describe("ProviderCommitMessageGenerator", () => {
     resolvedProvider = {
       provider: mockProvider,
       configuredProviderName: "ollama",
-      selectedProviderName: "ollama",
-      usedFallbackPrimary: false,
     };
     const gen = getCommitMessageGenerator();
     const result = await gen.generateCommitMessage(baseContext, {
@@ -364,8 +356,6 @@ describe("ProviderCommitMessageGenerator", () => {
     resolvedProvider = {
       provider: mockProvider,
       configuredProviderName: "exotic-provider",
-      selectedProviderName: "exotic-provider",
-      usedFallbackPrimary: false,
     };
     const gen = getCommitMessageGenerator();
     const result = await gen.generateCommitMessage(baseContext, {
@@ -383,8 +373,6 @@ describe("ProviderCommitMessageGenerator", () => {
     resolvedProvider = {
       provider: mockProvider,
       configuredProviderName: "ollama",
-      selectedProviderName: "ollama",
-      usedFallbackPrimary: false,
     };
     currentConfig.workspaceGit.commitMessageLLM.providerFastModelOverrides = {
       ollama: "llama3.2:3b",
@@ -404,29 +392,4 @@ describe("ProviderCommitMessageGenerator", () => {
     expect(options.config.model).toBe("llama3.2:3b");
   });
 
-  // 15. Fail-open fallback provider uses fallback provider's fast-model mapping
-  test("configured provider unavailable -> selected fallback provider model mapping is used", async () => {
-    currentConfig.services.inference.provider = "anthropic";
-    currentConfig.providerOrder = ["openai"];
-    mockSecureKeys = { openai: "sk-openai" };
-    resolvedProvider = {
-      provider: mockProvider,
-      configuredProviderName: "anthropic",
-      selectedProviderName: "openai",
-      usedFallbackPrimary: true,
-    };
-    mockSendMessage.mockResolvedValueOnce(
-      makeSuccessResponse("fix: fail-open commit"),
-    );
-
-    const gen = getCommitMessageGenerator();
-    const result = await gen.generateCommitMessage(baseContext, {
-      changedFiles: baseContext.changedFiles,
-    });
-
-    expect(result.source).toBe("llm");
-    const callArgs = mockSendMessage.mock.calls[0];
-    const options = callArgs[3] as { config: { model: string } };
-    expect(options.config.model).toBe("gpt-4o-mini");
-  });
 });

package/src/__tests__/provider-error-scenarios.test.ts

@@ -107,7 +107,6 @@ mock.module("../util/retry.js", () => {
   };
 });
 
-import { FailoverProvider } from "../providers/failover.js";
 import { RetryProvider } from "../providers/retry.js";
 import { createStreamTimeout } from "../providers/stream-timeout.js";
 import type {
@@ -139,18 +138,6 @@ function successResponse(
   };
 }
 
-function makeProvider(name = "mock"): Provider & { calls: number } {
-  const p = {
-    name,
-    calls: 0,
-    async sendMessage(): Promise<ProviderResponse> {
-      p.calls++;
-      return successResponse();
-    },
-  };
-  return p;
-}
-
 /** Provider that fails N times then succeeds. */
 function makeFlaky(
   failCount: number,
@@ -646,220 +633,6 @@ describe("RetryProvider — streaming response handling", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// FailoverProvider — model unavailability fallback
-// ---------------------------------------------------------------------------
-
-describe("FailoverProvider — model unavailability fallback", () => {
-  test("falls back to secondary when primary returns 500", async () => {
-    const primary = makeFailing(
-      new ProviderError("down", "primary", 500),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    const result = await provider.sendMessage(MESSAGES);
-
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(1);
-    expect(result.stopReason).toBe("end_turn");
-  });
-
-  test("falls back to secondary when primary returns 429", async () => {
-    const primary = makeFailing(
-      new ProviderError("rate limited", "primary", 429),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    const result = await provider.sendMessage(MESSAGES);
-
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(1);
-    expect(result.model).toBe("test-model");
-  });
-
-  test("falls back on ECONNREFUSED network error", async () => {
-    const err = new Error("connection refused");
-    (err as NodeJS.ErrnoException).code = "ECONNREFUSED";
-    const primary = makeFailing(err, "primary");
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    const result = await provider.sendMessage(MESSAGES);
-
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(1);
-    expect(result.content[0]).toMatchObject({ type: "text", text: "ok" });
-  });
-
-  test("falls back on ProviderError without status code (connection failure)", async () => {
-    const primary = makeFailing(
-      new ProviderError("connection failed", "primary"),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    const _result = await provider.sendMessage(MESSAGES);
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(1);
-  });
-
-  test("does NOT fall back on 400 Bad Request", async () => {
-    const primary = makeFailing(
-      new ProviderError("bad request", "primary", 400),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow("bad request");
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(0);
-  });
-
-  test("does NOT fall back on 401 Unauthorized", async () => {
-    const primary = makeFailing(
-      new ProviderError("unauthorized", "primary", 401),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary]);
-
-    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow(
-      "unauthorized",
-    );
-    expect(secondary.calls).toBe(0);
-  });
-
-  test("throws last error when all providers fail", async () => {
-    const p1 = makeFailing(new ProviderError("p1 down", "p1", 500), "p1");
-    const p2 = makeFailing(new ProviderError("p2 down", "p2", 503), "p2");
-    const p3 = makeFailing(new ProviderError("p3 down", "p3", 502), "p3");
-    const provider = new FailoverProvider([p1, p2, p3]);
-
-    try {
-      await provider.sendMessage(MESSAGES);
-      expect(true).toBe(false);
-    } catch (err) {
-      expect(err).toBeInstanceOf(ProviderError);
-      // Last provider's error is thrown
-      expect((err as ProviderError).message).toBe("p3 down");
-    }
-    expect(p1.calls).toBe(1);
-    expect(p2.calls).toBe(1);
-    expect(p3.calls).toBe(1);
-  });
-
-  test("chains through three providers when first two fail", async () => {
-    const p1 = makeFailing(new ProviderError("p1 error", "p1", 500), "p1");
-    const p2 = makeFailing(new ProviderError("p2 error", "p2", 502), "p2");
-    const p3 = makeProvider("p3");
-    const provider = new FailoverProvider([p1, p2, p3]);
-
-    const result = await provider.sendMessage(MESSAGES);
-
-    expect(p1.calls).toBe(1);
-    expect(p2.calls).toBe(1);
-    expect(p3.calls).toBe(1);
-    expect(result.stopReason).toBe("end_turn");
-  });
-
-  test("requires at least one provider", () => {
-    expect(() => new FailoverProvider([])).toThrow(
-      "FailoverProvider requires at least one provider",
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// FailoverProvider — cooldown and recovery
-// ---------------------------------------------------------------------------
-
-describe("FailoverProvider — cooldown and recovery", () => {
-  test("skips provider in cooldown period", async () => {
-    const primary = makeFailing(
-      new ProviderError("down", "primary", 500),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-    // Use a long cooldown so primary stays unhealthy
-    const provider = new FailoverProvider([primary, secondary], 60_000);
-
-    // First call: primary fails, secondary succeeds
-    await provider.sendMessage(MESSAGES);
-    expect(primary.calls).toBe(1);
-    expect(secondary.calls).toBe(1);
-
-    // Second call: primary is in cooldown, skipped — goes straight to secondary
-    await provider.sendMessage(MESSAGES);
-    expect(primary.calls).toBe(1); // not called again
-    expect(secondary.calls).toBe(2);
-  });
-
-  test("retries provider after cooldown expires", async () => {
-    let primaryCallCount = 0;
-    const primary: Provider = {
-      name: "primary",
-      async sendMessage() {
-        primaryCallCount++;
-        if (primaryCallCount === 1) {
-          throw new ProviderError("temporarily down", "primary", 500);
-        }
-        return successResponse();
-      },
-    };
-    const secondary = makeProvider("secondary");
-    // Very short cooldown
-    const provider = new FailoverProvider([primary, secondary], 1);
-
-    // First call: primary fails, marked unhealthy, secondary succeeds
-    await provider.sendMessage(MESSAGES);
-    expect(primaryCallCount).toBe(1);
-
-    // Wait for cooldown to expire
-    await new Promise((r) => setTimeout(r, 10));
-
-    // Second call: primary should be retried after cooldown expired
-    await provider.sendMessage(MESSAGES);
-    expect(primaryCallCount).toBe(2);
-  });
-
-  test("marks provider healthy after successful recovery", async () => {
-    let primaryCallCount = 0;
-    const primary: Provider = {
-      name: "primary",
-      async sendMessage() {
-        primaryCallCount++;
-        if (primaryCallCount === 1) {
-          throw new ProviderError("blip", "primary", 500);
-        }
-        return successResponse();
-      },
-    };
-    const secondary = makeProvider("secondary");
-    const provider = new FailoverProvider([primary, secondary], 1);
-
-    // First call: primary fails
-    await provider.sendMessage(MESSAGES);
-    expect(primaryCallCount).toBe(1);
-
-    // Wait for cooldown
-    await new Promise((r) => setTimeout(r, 10));
-
-    // Second call: primary recovers
-    await provider.sendMessage(MESSAGES);
-    expect(primaryCallCount).toBe(2);
-
-    // Third call: primary is healthy, used directly
-    await provider.sendMessage(MESSAGES);
-    expect(primaryCallCount).toBe(3);
-    expect(secondary.calls).toBe(1); // only called once during initial failover
-  });
-});
 
 // ---------------------------------------------------------------------------
 // createStreamTimeout — edge cases
@@ -910,43 +683,3 @@ describe("createStreamTimeout — edge cases", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// RetryProvider + FailoverProvider — combined scenarios
-// ---------------------------------------------------------------------------
-
-describe("RetryProvider + FailoverProvider — combined", () => {
-  test("failover wrapping retry: each provider in the chain retries independently", async () => {
-    // Primary always fails with 500, secondary succeeds
-    const primary = makeFailing(
-      new ProviderError("primary down", "primary", 500),
-      "primary",
-    );
-    const secondary = makeProvider("secondary");
-
-    // Wrap each in RetryProvider, then combine with FailoverProvider
-    const retryPrimary = new RetryProvider(primary);
-    const retrySecondary = new RetryProvider(secondary);
-    const failover = new FailoverProvider([retryPrimary, retrySecondary]);
-
-    const result = await failover.sendMessage(MESSAGES);
-    expect(result.stopReason).toBe("end_turn");
-    // Primary should have been retried MAX_RETRIES + 1 times before failover
-    expect(primary.calls).toBe(DEFAULT_MAX_RETRIES + 1);
-    expect(secondary.calls).toBe(1);
-  });
-
-  test("single provider: retry exhaustion produces the original error", async () => {
-    const inner = makeFailing(new ProviderError("always fail", "solo", 500));
-    const retrying = new RetryProvider(inner);
-
-    try {
-      await retrying.sendMessage(MESSAGES);
-      expect(true).toBe(false);
-    } catch (err) {
-      expect(err).toBeInstanceOf(ProviderError);
-      expect((err as ProviderError).message).toBe("always fail");
-      expect((err as ProviderError).statusCode).toBe(500);
-    }
-    expect(inner.calls).toBe(DEFAULT_MAX_RETRIES + 1);
-  });
-});

package/src/__tests__/provider-managed-proxy-integration.test.ts

@@ -193,13 +193,12 @@ describe("managed proxy integration — credential precedence", () => {
 
       const provider = getProvider("anthropic");
 
-      // Unwrap RetryProvider → LogfireProvider → AnthropicProvider to inspect
-      // the Anthropic SDK client's baseURL. The wrappers use private `inner`
-      // and AnthropicProvider stores the SDK client as private `client`.
+      // Unwrap RetryProvider → AnthropicProvider to inspect the Anthropic
+      // SDK client's baseURL. RetryProvider stores the inner provider as
+      // private `inner` and AnthropicProvider stores the SDK client as
+      // private `client`.
       const retryInner = (provider as any).inner;
-      // retryInner is the logfire wrapper; it also has an `inner` property
-      const logfireInner = (retryInner as any).inner ?? retryInner;
-      const anthropicClient = (logfireInner as any).client;
+      const anthropicClient = (retryInner as any).client;
 
       expect(anthropicClient).toBeDefined();
       const baseURL: string = anthropicClient.baseURL;