feat: add Bedrock support for Claude Agent SDK adapter

dafzthomas · claude · dafzthomas · commit e7f28c2b1caf · 2026-03-18T13:57:18.000Z
- Add useBedrock, awsRegion, awsProfile, and per-tier ARN override
  fields to ClaudeProviderStartOptions contract
- Add resolveBedrockModel() and buildBedrockEnv() helpers to
  ClaudeAdapter for model slug → ARN resolution and env injection
- Store bedrockOptions in session context so sendTurn can resolve
  models without receiving providerOptions on each turn
- Wire Bedrock settings from appSettings through providerOptions
  dispatch in ChatView
- Add Bedrock configuration section to settings UI with toggle,
  region, profile, and per-tier ARN override inputs
- Extend desktop syncShellEnvironment to read AWS/Bedrock env vars
  from login shell (AWS_REGION, AWS_PROFILE, credentials, etc.)
- Add tests for AWS env var sync in desktop

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/apps/desktop/src/syncShellEnvironment.test.ts b/apps/desktop/src/syncShellEnvironment.test.ts
@@ -18,7 +18,17 @@ describe("syncShellEnvironment", () => {
       readEnvironment,
     });
 
-    expect(readEnvironment).toHaveBeenCalledWith("/bin/zsh", ["PATH", "SSH_AUTH_SOCK"]);
+    expect(readEnvironment).toHaveBeenCalledWith("/bin/zsh", [
+      "PATH",
+      "SSH_AUTH_SOCK",
+      "AWS_REGION",
+      "AWS_DEFAULT_REGION",
+      "AWS_PROFILE",
+      "AWS_ACCESS_KEY_ID",
+      "AWS_SECRET_ACCESS_KEY",
+      "AWS_SESSION_TOKEN",
+      "CLAUDE_CODE_USE_BEDROCK",
+    ]);
     expect(env.PATH).toBe("/opt/homebrew/bin:/usr/bin");
     expect(env.SSH_AUTH_SOCK).toBe("/tmp/secretive.sock");
   });
@@ -82,4 +92,48 @@ describe("syncShellEnvironment", () => {
     expect(env.PATH).toBe("/usr/bin");
     expect(env.SSH_AUTH_SOCK).toBe("/tmp/inherited.sock");
   });
+
+  it("hydrates missing AWS/Bedrock env vars from the login shell", () => {
+    const env: NodeJS.ProcessEnv = {
+      SHELL: "/bin/zsh",
+      PATH: "/usr/bin",
+    };
+    const readEnvironment = vi.fn(() => ({
+      PATH: "/usr/bin",
+      AWS_REGION: "us-west-2",
+      AWS_PROFILE: "bedrock-dev",
+      CLAUDE_CODE_USE_BEDROCK: "1",
+    }));
+
+    syncShellEnvironment(env, {
+      platform: "darwin",
+      readEnvironment,
+    });
+
+    expect(env.AWS_REGION).toBe("us-west-2");
+    expect(env.AWS_PROFILE).toBe("bedrock-dev");
+    expect(env.CLAUDE_CODE_USE_BEDROCK).toBe("1");
+  });
+
+  it("preserves inherited AWS env vars over login shell values", () => {
+    const env: NodeJS.ProcessEnv = {
+      SHELL: "/bin/zsh",
+      PATH: "/usr/bin",
+      AWS_REGION: "eu-west-1",
+      AWS_PROFILE: "production",
+    };
+    const readEnvironment = vi.fn(() => ({
+      PATH: "/usr/bin",
+      AWS_REGION: "us-west-2",
+      AWS_PROFILE: "bedrock-dev",
+    }));
+
+    syncShellEnvironment(env, {
+      platform: "darwin",
+      readEnvironment,
+    });
+
+    expect(env.AWS_REGION).toBe("eu-west-1");
+    expect(env.AWS_PROFILE).toBe("production");
+  });
 });
diff --git a/apps/desktop/src/syncShellEnvironment.ts b/apps/desktop/src/syncShellEnvironment.ts
@@ -1,5 +1,15 @@
 import { readEnvironmentFromLoginShell, ShellEnvironmentReader } from "@t3tools/shared/shell";
 
+const AWS_ENV_VARS = [
+  "AWS_REGION",
+  "AWS_DEFAULT_REGION",
+  "AWS_PROFILE",
+  "AWS_ACCESS_KEY_ID",
+  "AWS_SECRET_ACCESS_KEY",
+  "AWS_SESSION_TOKEN",
+  "CLAUDE_CODE_USE_BEDROCK",
+] as const;
+
 export function syncShellEnvironment(
   env: NodeJS.ProcessEnv = process.env,
   options: {
@@ -14,6 +24,7 @@ export function syncShellEnvironment(
     const shellEnvironment = (options.readEnvironment ?? readEnvironmentFromLoginShell)(shell, [
       "PATH",
       "SSH_AUTH_SOCK",
+      ...AWS_ENV_VARS,
     ]);
 
     if (shellEnvironment.PATH) {
@@ -23,6 +34,12 @@ export function syncShellEnvironment(
     if (!env.SSH_AUTH_SOCK && shellEnvironment.SSH_AUTH_SOCK) {
       env.SSH_AUTH_SOCK = shellEnvironment.SSH_AUTH_SOCK;
     }
+
+    for (const key of AWS_ENV_VARS) {
+      if (!env[key] && shellEnvironment[key]) {
+        env[key] = shellEnvironment[key];
+      }
+    }
   } catch {
     // Keep inherited environment if shell lookup fails.
   }
diff --git a/apps/server/src/provider/Layers/ClaudeAdapter.ts b/apps/server/src/provider/Layers/ClaudeAdapter.ts
@@ -128,6 +128,7 @@ interface ClaudeSessionContext {
   readonly query: ClaudeQueryRuntime;
   readonly startedAt: string;
   readonly basePermissionMode: PermissionMode | undefined;
+  readonly bedrockOptions: BedrockOptions | undefined;
   resumeSessionId: string | undefined;
   readonly pendingApprovals: Map<ApprovalRequestId, PendingApproval>;
   readonly pendingUserInputs: Map<ApprovalRequestId, PendingUserInput>;
@@ -199,6 +200,71 @@ function toPermissionMode(value: unknown): PermissionMode | undefined {
   }
 }
 
+// ── Bedrock helpers ──────────────────────────────────────────────────
+
+interface BedrockOptions {
+  readonly useBedrock?: boolean | undefined;
+  readonly awsRegion?: string | undefined;
+  readonly awsProfile?: string | undefined;
+  readonly bedrockModelOverrideHaiku?: string | undefined;
+  readonly bedrockModelOverrideSonnet?: string | undefined;
+  readonly bedrockModelOverrideOpus?: string | undefined;
+}
+
+function isBedrockActive(opts: BedrockOptions | undefined): boolean {
+  if (!opts) return false;
+  return Boolean(
+    opts.useBedrock ||
+      opts.awsRegion ||
+      opts.awsProfile ||
+      opts.bedrockModelOverrideHaiku ||
+      opts.bedrockModelOverrideSonnet ||
+      opts.bedrockModelOverrideOpus,
+  );
+}
+
+function resolveBedrockModel(
+  modelSlug: string | undefined,
+  opts: BedrockOptions,
+): string | undefined {
+  if (!modelSlug) return opts.bedrockModelOverrideSonnet ?? opts.bedrockModelOverrideOpus;
+  const slug = modelSlug.toLowerCase();
+  if (slug.includes("haiku") && opts.bedrockModelOverrideHaiku) return opts.bedrockModelOverrideHaiku;
+  if (slug.includes("opus") && opts.bedrockModelOverrideOpus) return opts.bedrockModelOverrideOpus;
+  if (opts.bedrockModelOverrideSonnet) return opts.bedrockModelOverrideSonnet;
+  if (opts.bedrockModelOverrideOpus) return opts.bedrockModelOverrideOpus;
+  return undefined;
+}
+
+function buildBedrockEnv(
+  baseEnv: NodeJS.ProcessEnv,
+  opts: BedrockOptions,
+  resolvedModelArn: string | undefined,
+): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = { ...baseEnv };
+  env.CLAUDE_CODE_USE_BEDROCK = "1";
+  if (opts.awsRegion) {
+    env.AWS_REGION = opts.awsRegion;
+    env.ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION = opts.awsRegion;
+  }
+  if (opts.awsProfile) {
+    env.AWS_PROFILE = opts.awsProfile;
+  }
+  if (opts.bedrockModelOverrideHaiku) {
+    env.ANTHROPIC_DEFAULT_HAIKU_MODEL = opts.bedrockModelOverrideHaiku;
+  }
+  if (opts.bedrockModelOverrideSonnet) {
+    env.ANTHROPIC_DEFAULT_SONNET_MODEL = opts.bedrockModelOverrideSonnet;
+  }
+  if (opts.bedrockModelOverrideOpus) {
+    env.ANTHROPIC_DEFAULT_OPUS_MODEL = opts.bedrockModelOverrideOpus;
+  }
+  if (resolvedModelArn) {
+    env.ANTHROPIC_MODEL = resolvedModelArn;
+  }
+  return env;
+}
+
 function readClaudeResumeState(resumeCursor: unknown): ClaudeResumeState | undefined {
   if (!resumeCursor || typeof resumeCursor !== "object") {
     return undefined;
@@ -2209,6 +2275,14 @@ function makeClaudeAdapter(options?: ClaudeAdapterLiveOptions) {
           );
 
         const providerOptions = input.providerOptions?.claudeAgent;
+        const bedrock = isBedrockActive(providerOptions);
+        const resolvedModelArn = bedrock
+          ? resolveBedrockModel(input.model, providerOptions!)
+          : undefined;
+        const sessionModel = bedrock ? resolvedModelArn : input.model;
+        const sessionEnv = bedrock
+          ? buildBedrockEnv(process.env, providerOptions!, resolvedModelArn)
+          : process.env;
         const requestedEffort = resolveReasoningEffortForProvider(
           "claudeAgent",
           input.modelOptions?.claudeAgent?.effort ?? null,
@@ -2236,7 +2310,7 @@ function makeClaudeAdapter(options?: ClaudeAdapterLiveOptions) {
 
         const queryOptions: ClaudeQueryOptions = {
           ...(input.cwd ? { cwd: input.cwd } : {}),
-          ...(input.model ? { model: input.model } : {}),
+          ...(sessionModel ? { model: sessionModel } : {}),
           ...(providerOptions?.binaryPath
             ? { pathToClaudeCodeExecutable: providerOptions.binaryPath }
             : {}),
@@ -2253,7 +2327,7 @@ function makeClaudeAdapter(options?: ClaudeAdapterLiveOptions) {
           ...(resumeState?.resumeSessionAt ? { resumeSessionAt: resumeState.resumeSessionAt } : {}),
           includePartialMessages: true,
           canUseTool,
-          env: process.env,
+          env: sessionEnv,
           ...(input.cwd ? { additionalDirectories: [input.cwd] } : {}),
         };
 
@@ -2298,6 +2372,7 @@ function makeClaudeAdapter(options?: ClaudeAdapterLiveOptions) {
           query: queryRuntime,
           startedAt,
           basePermissionMode: permissionMode,
+          bedrockOptions: bedrock ? providerOptions : undefined,
           resumeSessionId: resumeState?.resume,
           pendingApprovals,
           pendingUserInputs,
@@ -2375,10 +2450,15 @@ function makeClaudeAdapter(options?: ClaudeAdapterLiveOptions) {
         }
 
         if (input.model) {
-          yield* Effect.tryPromise({
-            try: () => context.query.setModel(input.model),
-            catch: (cause) => toRequestError(input.threadId, "turn/setModel", cause),
-          });
+          const turnModel = context.bedrockOptions
+            ? resolveBedrockModel(input.model, context.bedrockOptions)
+            : input.model;
+          if (turnModel) {
+            yield* Effect.tryPromise({
+              try: () => context.query.setModel(turnModel),
+              catch: (cause) => toRequestError(input.threadId, "turn/setModel", cause),
+            });
+          }
         }
 
         // Apply interaction mode by switching the SDK's permission mode.
diff --git a/apps/web/src/appSettings.ts b/apps/web/src/appSettings.ts
@@ -39,6 +39,24 @@ const AppSettingsSchema = Schema.Struct({
     Schema.withConstructorDefault(() => Option.some([])),
   ),
   textGenerationModel: Schema.optional(TrimmedNonEmptyString),
+  claudeUseBedrock: Schema.Boolean.pipe(
+    Schema.withConstructorDefault(() => Option.some(false)),
+  ),
+  claudeAwsRegion: Schema.String.check(Schema.isMaxLength(256)).pipe(
+    Schema.withConstructorDefault(() => Option.some("")),
+  ),
+  claudeAwsProfile: Schema.String.check(Schema.isMaxLength(256)).pipe(
+    Schema.withConstructorDefault(() => Option.some("")),
+  ),
+  claudeBedrockArnHaiku: Schema.String.check(Schema.isMaxLength(1024)).pipe(
+    Schema.withConstructorDefault(() => Option.some("")),
+  ),
+  claudeBedrockArnSonnet: Schema.String.check(Schema.isMaxLength(1024)).pipe(
+    Schema.withConstructorDefault(() => Option.some("")),
+  ),
+  claudeBedrockArnOpus: Schema.String.check(Schema.isMaxLength(1024)).pipe(
+    Schema.withConstructorDefault(() => Option.some("")),
+  ),
 });
 export type AppSettings = typeof AppSettingsSchema.Type;
 export interface AppModelOption {
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
@@ -661,16 +661,50 @@ export default function ChatView({ threadId }: ChatViewProps) {
     return undefined;
   }, [draftModelOptions, selectedModel, selectedProvider]);
   const providerOptionsForDispatch = useMemo(() => {
-    if (!settings.codexBinaryPath && !settings.codexHomePath) {
-      return undefined;
-    }
+    const codex =
+      settings.codexBinaryPath || settings.codexHomePath
+        ? {
+            ...(settings.codexBinaryPath ? { binaryPath: settings.codexBinaryPath } : {}),
+            ...(settings.codexHomePath ? { homePath: settings.codexHomePath } : {}),
+          }
+        : undefined;
+    const claudeAgent =
+      settings.claudeUseBedrock ||
+      settings.claudeAwsRegion ||
+      settings.claudeAwsProfile ||
+      settings.claudeBedrockArnHaiku ||
+      settings.claudeBedrockArnSonnet ||
+      settings.claudeBedrockArnOpus
+        ? {
+            ...(settings.claudeUseBedrock ? { useBedrock: true } : {}),
+            ...(settings.claudeAwsRegion ? { awsRegion: settings.claudeAwsRegion } : {}),
+            ...(settings.claudeAwsProfile ? { awsProfile: settings.claudeAwsProfile } : {}),
+            ...(settings.claudeBedrockArnHaiku
+              ? { bedrockModelOverrideHaiku: settings.claudeBedrockArnHaiku }
+              : {}),
+            ...(settings.claudeBedrockArnSonnet
+              ? { bedrockModelOverrideSonnet: settings.claudeBedrockArnSonnet }
+              : {}),
+            ...(settings.claudeBedrockArnOpus
+              ? { bedrockModelOverrideOpus: settings.claudeBedrockArnOpus }
+              : {}),
+          }
+        : undefined;
+    if (!codex && !claudeAgent) return undefined;
     return {
-      codex: {
-        ...(settings.codexBinaryPath ? { binaryPath: settings.codexBinaryPath } : {}),
-        ...(settings.codexHomePath ? { homePath: settings.codexHomePath } : {}),
-      },
+      ...(codex ? { codex } : {}),
+      ...(claudeAgent ? { claudeAgent } : {}),
     };
-  }, [settings.codexBinaryPath, settings.codexHomePath]);
+  }, [
+    settings.codexBinaryPath,
+    settings.codexHomePath,
+    settings.claudeUseBedrock,
+    settings.claudeAwsRegion,
+    settings.claudeAwsProfile,
+    settings.claudeBedrockArnHaiku,
+    settings.claudeBedrockArnSonnet,
+    settings.claudeBedrockArnOpus,
+  ]);
   const selectedModelForPicker = selectedModel;
   const modelOptionsByProvider = useMemo(
     () => getCustomModelOptionsByProvider(settings),
diff --git a/apps/web/src/routes/_chat.settings.tsx b/apps/web/src/routes/_chat.settings.tsx
diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.ts
