opencode-crs-bedrock 1.0.1

package/index.ts

@@ -0,0 +1,1060 @@
+/**
+ * OpenCode CRS Bedrock Plugin
+ *
+ * Enables OpenCode to connect to FeedMob CRS (Claude Relay Service) proxy
+ * for AWS Bedrock Anthropic models.
+ *
+ * Handles:
+ * - API key authentication (x-api-key header)
+ * - SSE stream transformation to fix @ai-sdk/anthropic compatibility
+ * - Missing content_block_start/stop event injection
+ * - Tool name inference from accumulated JSON parameters
+ * - Bedrock model ID mapping to standard Anthropic format
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+import type { Auth, Provider } from "@opencode-ai/sdk";
+
+// ============================================================================
+// Type Definitions
+// ============================================================================
+
+/** Valid SSE event types that the Anthropic SDK expects */
+type SSEEventType =
+  | "message_start"
+  | "content_block_start"
+  | "content_block_delta"
+  | "content_block_stop"
+  | "message_delta"
+  | "message_stop"
+  | "ping"
+  | "error";
+
+/** Tool definition from Anthropic API */
+interface Tool {
+  name: string;
+  description?: string;
+  input_schema?: {
+    type?: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+  };
+}
+
+/** Schema info extracted from a tool for parameter matching */
+interface ToolSchema {
+  params: Record<string, unknown>;
+  required: Set<string>;
+}
+
+/** Content block types in Anthropic responses */
+interface TextContentBlock {
+  type: "text";
+  text: string;
+}
+
+interface ToolUseContentBlock {
+  type: "tool_use";
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+}
+
+type ContentBlock = TextContentBlock | ToolUseContentBlock;
+
+/** Delta types in content_block_delta events */
+interface TextDelta {
+  type: "text_delta";
+  text: string;
+}
+
+interface InputJsonDelta {
+  type: "input_json_delta";
+  partial_json: string;
+}
+
+type Delta = TextDelta | InputJsonDelta;
+
+/** SSE event data structures */
+interface ContentBlockStartData {
+  type: "content_block_start";
+  index: number;
+  content_block: ContentBlock;
+}
+
+interface ContentBlockDeltaData {
+  type: "content_block_delta";
+  index: number;
+  delta: Delta;
+}
+
+interface ContentBlockStopData {
+  type: "content_block_stop";
+  index: number;
+}
+
+interface MessageStartData {
+  type: "message_start" | "message";
+  message?: {
+    id?: string;
+    type?: string;
+    role?: string;
+    model?: string;
+    content?: ContentBlock[];
+    stop_reason?: string | null;
+    stop_sequence?: string | null;
+    usage?: {
+      input_tokens: number;
+      output_tokens: number;
+    };
+  };
+  // Fields present when type is "message" (CRS format)
+  id?: string;
+  role?: string;
+  model?: string;
+  content?: ContentBlock[];
+  stop_reason?: string | null;
+  stop_sequence?: string | null;
+  usage?: {
+    input_tokens: number;
+    output_tokens: number;
+  };
+}
+
+interface MessageDeltaData {
+  type: "message_delta";
+  delta?: {
+    stop_reason?: string;
+    stop_sequence?: string | null;
+  };
+  usage?: {
+    output_tokens: number;
+  };
+}
+
+type SSEEventData =
+  | ContentBlockStartData
+  | ContentBlockDeltaData
+  | ContentBlockStopData
+  | MessageStartData
+  | MessageDeltaData
+  | Record<string, unknown>;
+
+/** Block tracking info for started content blocks */
+interface TextBlockInfo {
+  type: "text";
+  emitted: boolean;
+}
+
+interface ToolUseBlockInfo {
+  type: "tool_use";
+  id: string;
+  name: string;
+  inputBuffer: string;
+  emitted: boolean;
+}
+
+type BlockInfo = TextBlockInfo | ToolUseBlockInfo;
+
+/** Buffered delta for pending tool blocks */
+interface BufferedDelta {
+  event: string;
+  data: Record<string, unknown>;
+}
+
+/** Pending tool block awaiting name inference */
+interface PendingToolBlock {
+  toolId: string;
+  deltas: BufferedDelta[];
+  inputBuffer: string;
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+const PROVIDER_ID = "crs";
+
+const VALID_SSE_EVENT_TYPES: Set<SSEEventType> = new Set([
+  "message_start",
+  "content_block_start",
+  "content_block_delta",
+  "content_block_stop",
+  "message_delta",
+  "message_stop",
+  "ping",
+  "error",
+]);
+
+const DEBUG_SSE = process.env.CRS_DEBUG_SSE === "true";
+
+function debugLog(...args: unknown[]): void {
+  if (DEBUG_SSE) {
+    console.error("[CRS-SSE]", ...args);
+  }
+}
+
+// ============================================================================
+// SSE Helper Functions
+// ============================================================================
+
+/**
+ * Generate a tool use ID in Anthropic's format
+ */
+function generateToolUseId(): string {
+  const chars =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "toolu_01";
+  for (let i = 0; i < 22; i++) {
+    id += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return id;
+}
+
+/**
+ * Emit a complete SSE event (event line + data line + separator)
+ */
+function emitSSEEvent(
+  controller: TransformStreamDefaultController<string>,
+  eventType: string,
+  data: Record<string, unknown>
+): void {
+  controller.enqueue(`event: ${eventType}\n`);
+  controller.enqueue(`data: ${JSON.stringify(data)}\n`);
+  controller.enqueue("\n");
+}
+
+/**
+ * Emit just the event type header (for re-emitting after injections)
+ */
+function emitEventHeader(
+  controller: TransformStreamDefaultController<string>,
+  eventType: string
+): void {
+  controller.enqueue(`event: ${eventType}\n`);
+}
+
+// ============================================================================
+// Tool Name Inference
+// ============================================================================
+
+/**
+ * Build tool schema map for parameter-based tool name inference
+ */
+function buildToolSchemas(tools: Tool[]): Map<string, ToolSchema> {
+  const schemas = new Map<string, ToolSchema>();
+  for (const tool of tools) {
+    const params = tool.input_schema?.properties || {};
+    const required = new Set(tool.input_schema?.required || []);
+    schemas.set(tool.name, { params, required });
+  }
+  return schemas;
+}
+
+/**
+ * Infer tool name from accumulated JSON input by matching parameters against tool schemas
+ */
+function inferToolName(
+  jsonStr: string,
+  toolSchemas: Map<string, ToolSchema>
+): string | null {
+  try {
+    const input = JSON.parse(jsonStr) as Record<string, unknown>;
+    const inputKeys = new Set(Object.keys(input));
+
+    let bestMatch: string | null = null;
+    let bestScore = -1;
+
+    for (const [toolName, schema] of toolSchemas) {
+      const schemaKeys = new Set(Object.keys(schema.params));
+
+      // Count matching and mismatching keys
+      let matchCount = 0;
+      let mismatchCount = 0;
+      for (const key of inputKeys) {
+        if (schemaKeys.has(key)) {
+          matchCount++;
+        } else {
+          mismatchCount++;
+        }
+      }
+
+      // Check if all required params are present
+      let hasAllRequired = true;
+      for (const req of schema.required) {
+        if (!inputKeys.has(req)) {
+          hasAllRequired = false;
+          break;
+        }
+      }
+
+      // Score: matches - mismatches, bonus for having all required
+      const score = matchCount - mismatchCount + (hasAllRequired ? 10 : 0);
+      if (score > bestScore) {
+        bestScore = score;
+        bestMatch = toolName;
+      }
+    }
+
+    return bestMatch;
+  } catch {
+    return null;
+  }
+}
+
+// ============================================================================
+// Model ID Mapping
+// ============================================================================
+
+const BEDROCK_MODEL_MAPPINGS: Record<string, string> = {
+  "us.anthropic.claude-sonnet-4-20250514-v1:0": "claude-sonnet-4-20250514",
+  "us.anthropic.claude-opus-4-20250514-v1:0": "claude-opus-4-20250514",
+  "us.anthropic.claude-3-5-sonnet-20241022-v2:0": "claude-3-5-sonnet-20241022",
+  "us.anthropic.claude-3-5-haiku-20241022-v1:0": "claude-3-5-haiku-20241022",
+  "us.anthropic.claude-3-opus-20240229-v1:0": "claude-3-opus-20240229",
+};
+
+/**
+ * Maps Bedrock model IDs to standard Anthropic model IDs
+ */
+function mapBedrockModelId(bedrockModelId: string): string {
+  if (BEDROCK_MODEL_MAPPINGS[bedrockModelId]) {
+    return BEDROCK_MODEL_MAPPINGS[bedrockModelId];
+  }
+
+  // Try to extract the model name from Bedrock format
+  // Format: us.anthropic.<model-name>-v<version>:<variant>
+  const match = bedrockModelId.match(/us\.anthropic\.(.+?)-v\d+:\d+$/);
+  if (match) {
+    return match[1];
+  }
+
+  return bedrockModelId;
+}
+
+// ============================================================================
+// SSE Stream Transformer
+// ============================================================================
+
+/**
+ * State manager for SSE stream transformation
+ */
+class SSETransformState {
+  toolSchemas: Map<string, ToolSchema>;
+  buffer: string;
+  currentEventType: SSEEventType | null;
+  startedBlocks: Map<number, BlockInfo>;
+  pendingToolBlocks: Map<number, PendingToolBlock>;
+
+  constructor(toolSchemas: Map<string, ToolSchema>) {
+    this.toolSchemas = toolSchemas;
+    this.buffer = "";
+    this.currentEventType = null;
+    this.startedBlocks = new Map();
+    this.pendingToolBlocks = new Map();
+  }
+
+  /**
+   * Track a content_block_start event
+   */
+  trackBlockStart(index: number, contentBlock: ContentBlock | undefined): void {
+    const blockType = contentBlock?.type || "text";
+
+    if (blockType === "tool_use") {
+      const toolBlock = contentBlock as ToolUseContentBlock;
+      this.startedBlocks.set(index, {
+        type: "tool_use",
+        id: toolBlock.id || generateToolUseId(),
+        name: toolBlock.name || "unknown",
+        inputBuffer: "",
+        emitted: true,
+      });
+    } else {
+      this.startedBlocks.set(index, { type: "text", emitted: true });
+    }
+  }
+
+  /**
+   * Buffer a tool delta for later emission (when we can infer tool name)
+   */
+  bufferToolDelta(
+    index: number,
+    eventType: string,
+    data: Record<string, unknown>,
+    partialJson: string
+  ): void {
+    if (!this.pendingToolBlocks.has(index)) {
+      this.pendingToolBlocks.set(index, {
+        toolId: generateToolUseId(),
+        deltas: [],
+        inputBuffer: "",
+      });
+    }
+
+    const pending = this.pendingToolBlocks.get(index)!;
+    pending.inputBuffer += partialJson;
+    pending.deltas.push({ event: eventType, data: { ...data } });
+    debugLog("Buffering tool delta, accumulated:", pending.inputBuffer);
+  }
+
+  /**
+   * Check if a block index has pending (unbuffered) tool deltas
+   */
+  hasPendingToolBlock(index: number): boolean {
+    return this.pendingToolBlocks.has(index);
+  }
+
+  /**
+   * Flush all pending tool blocks - emit content_block_start with inferred name, then deltas
+   */
+  flushPendingToolBlocks(
+    controller: TransformStreamDefaultController<string>
+  ): void {
+    for (const [blockIndex, pending] of this.pendingToolBlocks) {
+      const inferredName =
+        inferToolName(pending.inputBuffer, this.toolSchemas) || "unknown";
+      debugLog(
+        "Flushing pending tool block",
+        blockIndex,
+        "with inferred name:",
+        inferredName
+      );
+
+      // Emit content_block_start with inferred tool name
+      emitSSEEvent(controller, "content_block_start", {
+        type: "content_block_start",
+        index: blockIndex,
+        content_block: {
+          type: "tool_use",
+          id: pending.toolId,
+          name: inferredName,
+          input: {},
+        },
+      });
+
+      // Emit all buffered deltas with proper type field
+      for (const buffered of pending.deltas) {
+        emitSSEEvent(controller, buffered.event, {
+          type: buffered.event,
+          ...buffered.data,
+        });
+      }
+
+      // Track as started
+      this.startedBlocks.set(blockIndex, {
+        type: "tool_use",
+        id: pending.toolId,
+        name: inferredName,
+        inputBuffer: pending.inputBuffer,
+        emitted: true,
+      });
+    }
+    this.pendingToolBlocks.clear();
+  }
+
+  /**
+   * Emit content_block_stop for all open blocks
+   */
+  closeAllBlocks(controller: TransformStreamDefaultController<string>): void {
+    for (const [blockIndex] of this.startedBlocks) {
+      emitSSEEvent(controller, "content_block_stop", {
+        type: "content_block_stop",
+        index: blockIndex,
+      });
+    }
+    this.startedBlocks.clear();
+  }
+}
+
+/**
+ * Creates a TransformStream that filters and normalizes SSE events
+ * to match what @ai-sdk/anthropic expects.
+ *
+ * CRS may be missing content_block_start/stop events, so we inject them.
+ */
+function createSSETransformStream(
+  tools: Tool[] = []
+): TransformStream<string, string> {
+  const state = new SSETransformState(buildToolSchemas(tools));
+
+  return new TransformStream<string, string>({
+    transform(chunk, controller) {
+      state.buffer += chunk;
+      const lines = state.buffer.split("\n");
+      state.buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        const result = processSSELine(line, state, controller);
+        if (result === "skip") continue;
+      }
+    },
+
+    flush(controller) {
+      if (state.buffer.trim()) {
+        controller.enqueue(state.buffer);
+      }
+    },
+  });
+}
+
+/**
+ * Process a single SSE line
+ * @returns "skip" if the line should not be passed through, undefined otherwise
+ */
+function processSSELine(
+  line: string,
+  state: SSETransformState,
+  controller: TransformStreamDefaultController<string>
+): "skip" | undefined {
+  const trimmedLine = line.trim();
+
+  // Empty line - SSE event separator
+  if (trimmedLine === "") {
+    controller.enqueue("\n");
+    state.currentEventType = null;
+    return;
+  }
+
+  // Comment line
+  if (trimmedLine.startsWith(":")) {
+    controller.enqueue(line + "\n");
+    return;
+  }
+
+  // Event type line
+  if (trimmedLine.startsWith("event:")) {
+    const eventType = trimmedLine.slice(6).trim() as SSEEventType;
+    if (!VALID_SSE_EVENT_TYPES.has(eventType)) {
+      state.currentEventType = null;
+      return "skip";
+    }
+    state.currentEventType = eventType;
+    controller.enqueue(line + "\n");
+    return;
+  }
+
+  // Data line
+  if (trimmedLine.startsWith("data:")) {
+    return processDataLine(trimmedLine, line, state, controller);
+  }
+
+  // Other lines - pass through
+  controller.enqueue(line + "\n");
+}
+
+/**
+ * Process an SSE data line
+ */
+function processDataLine(
+  trimmedLine: string,
+  originalLine: string,
+  state: SSETransformState,
+  controller: TransformStreamDefaultController<string>
+): "skip" | undefined {
+  const dataContent = trimmedLine.slice(5).trim();
+
+  // Pass through [DONE] marker
+  if (dataContent === "[DONE]") {
+    controller.enqueue(originalLine + "\n");
+    return;
+  }
+
+  // Skip data for filtered events
+  if (state.currentEventType === null) {
+    return "skip";
+  }
+
+  try {
+    const data = JSON.parse(dataContent) as SSEEventData;
+    debugLog(
+      "Event:",
+      state.currentEventType,
+      "Data:",
+      JSON.stringify(data).slice(0, 500)
+    );
+
+    const shouldSkip = handleEventData(data, state, controller);
+    if (shouldSkip) return "skip";
+
+    // Normalize and emit the data
+    const normalized = normalizeEventData(data, state.currentEventType);
+    controller.enqueue(`data: ${JSON.stringify(normalized)}\n`);
+  } catch {
+    // If parsing fails, pass through as-is
+    controller.enqueue(originalLine + "\n");
+  }
+}
+
+/**
+ * Handle parsed event data based on event type
+ * @returns true if the data should be skipped (not emitted)
+ */
+function handleEventData(
+  data: SSEEventData,
+  state: SSETransformState,
+  controller: TransformStreamDefaultController<string>
+): boolean {
+  const eventType = state.currentEventType;
+
+  // Track content_block_start events
+  if (
+    eventType === "content_block_start" &&
+    typeof (data as ContentBlockStartData).index === "number"
+  ) {
+    const blockData = data as ContentBlockStartData;
+    state.trackBlockStart(blockData.index, blockData.content_block);
+    return false;
+  }
+
+  // Handle content_block_delta events
+  if (
+    eventType === "content_block_delta" &&
+    typeof (data as ContentBlockDeltaData).index === "number"
+  ) {
+    return handleContentBlockDelta(
+      data as ContentBlockDeltaData,
+      state,
+      controller
+    );
+  }
+
+  // Handle content_block_stop - clear from tracking
+  if (
+    eventType === "content_block_stop" &&
+    typeof (data as ContentBlockStopData).index === "number"
+  ) {
+    state.startedBlocks.delete((data as ContentBlockStopData).index);
+    return false;
+  }
+
+  // Handle message_delta - flush pending blocks and close open ones
+  if (eventType === "message_delta") {
+    state.flushPendingToolBlocks(controller);
+    if (state.startedBlocks.size > 0) {
+      state.closeAllBlocks(controller);
+    }
+    emitEventHeader(controller, eventType);
+    return false;
+  }
+
+  return false;
+}
+
+/**
+ * Handle content_block_delta event
+ * @returns true if the delta should be skipped
+ */
+function handleContentBlockDelta(
+  data: ContentBlockDeltaData,
+  state: SSETransformState,
+  controller: TransformStreamDefaultController<string>
+): boolean {
+  const index = data.index;
+  const deltaType = data.delta?.type;
+
+  // New block we haven't seen before
+  if (!state.startedBlocks.has(index)) {
+    if (deltaType === "input_json_delta") {
+      // Tool use block - buffer until we can infer name
+      const jsonDelta = data.delta as InputJsonDelta;
+      state.bufferToolDelta(
+        index,
+        state.currentEventType!,
+        data as unknown as Record<string, unknown>,
+        jsonDelta.partial_json || ""
+      );
+      return true; // Skip emission
+    } else {
+      // Text block - inject content_block_start and emit
+      injectTextBlockStart(index, state, controller);
+    }
+  } else if (deltaType === "input_json_delta" && state.hasPendingToolBlock(index)) {
+    // Continue buffering pending tool block
+    const jsonDelta = data.delta as InputJsonDelta;
+    state.bufferToolDelta(
+      index,
+      state.currentEventType!,
+      data as unknown as Record<string, unknown>,
+      jsonDelta.partial_json || ""
+    );
+    return true; // Skip emission
+  } else if (deltaType === "input_json_delta") {
+    // Accumulate JSON for already-emitted tool_use blocks
+    const blockInfo = state.startedBlocks.get(index);
+    if (blockInfo?.type === "tool_use") {
+      const jsonDelta = data.delta as InputJsonDelta;
+      blockInfo.inputBuffer =
+        (blockInfo.inputBuffer || "") + (jsonDelta.partial_json || "");
+    }
+  }
+
+  // Fix delta type mismatch
+  fixDeltaTypeMismatch(data, state.startedBlocks.get(index));
+
+  return false;
+}
+
+/**
+ * Inject a content_block_start event for a text block
+ */
+function injectTextBlockStart(
+  index: number,
+  state: SSETransformState,
+  controller: TransformStreamDefaultController<string>
+): void {
+  state.startedBlocks.set(index, { type: "text", emitted: true });
+
+  emitSSEEvent(controller, "content_block_start", {
+    type: "content_block_start",
+    index: index,
+    content_block: { type: "text", text: "" },
+  });
+  emitEventHeader(controller, state.currentEventType!);
+}
+
+/**
+ * Fix delta type if it doesn't match block type
+ */
+function fixDeltaTypeMismatch(
+  data: ContentBlockDeltaData,
+  blockInfo: BlockInfo | undefined
+): void {
+  if (!blockInfo || !data.delta) return;
+
+  const blockType = blockInfo.type || "text";
+
+  if (blockType === "tool_use" && data.delta.type === "text_delta") {
+    // Convert text_delta to input_json_delta for tool_use blocks
+    const textDelta = data.delta as TextDelta;
+    (data as { delta: Delta }).delta = {
+      type: "input_json_delta",
+      partial_json: textDelta.text || "",
+    };
+  } else if (blockType === "text" && data.delta.type === "input_json_delta") {
+    // Convert input_json_delta to text_delta for text blocks
+    const jsonDelta = data.delta as InputJsonDelta;
+    (data as { delta: Delta }).delta = {
+      type: "text_delta",
+      text: jsonDelta.partial_json || "",
+    };
+  }
+}
+
+// ============================================================================
+// Event Data Normalization
+// ============================================================================
+
+/**
+ * Normalizes event data to match Anthropic SDK expectations
+ */
+function normalizeEventData(
+  data: SSEEventData,
+  eventType: SSEEventType
+): SSEEventData {
+  const normalized = { ...data };
+
+  // Add type field if missing - SDK requires it for discriminated union
+  if (!normalized.type) {
+    normalized.type = eventType;
+  }
+
+  // Normalize message_start events
+  if (eventType === "message_start") {
+    return normalizeMessageStart(data as MessageStartData);
+  }
+
+  // Normalize content_block_start events
+  if (eventType === "content_block_start") {
+    return normalizeContentBlockStart(normalized as ContentBlockStartData);
+  }
+
+  return normalized;
+}
+
+function normalizeMessageStart(data: MessageStartData): MessageStartData {
+  // CRS returns { type: "message", ... } but SDK expects { type: "message_start", message: { ... } }
+  if (data.type === "message" || !data.message) {
+    const messageData: Record<string, unknown> = { ...data };
+    delete messageData.type;
+
+    if (
+      typeof messageData.model === "string" &&
+      messageData.model.includes("us.anthropic.")
+    ) {
+      messageData.model = mapBedrockModelId(messageData.model);
+    }
+
+    return { type: "message_start", message: messageData } as MessageStartData;
+  }
+
+  // Already in correct format, just normalize model ID
+  if (data.message?.model?.includes("us.anthropic.")) {
+    const normalized: MessageStartData = {
+      ...data,
+      message: {
+        ...data.message,
+        model: mapBedrockModelId(data.message.model),
+      },
+    };
+    return normalized;
+  }
+
+  return data;
+}
+
+function normalizeContentBlockStart(
+  normalized: ContentBlockStartData
+): ContentBlockStartData {
+  if (!normalized.content_block) {
+    return {
+      ...normalized,
+      content_block: { type: "text", text: "" },
+    };
+  } else if (normalized.content_block.type === "tool_use") {
+    const toolBlock = normalized.content_block as ToolUseContentBlock;
+    return {
+      ...normalized,
+      content_block: {
+        ...toolBlock,
+        id: toolBlock.id || generateToolUseId(),
+        name: toolBlock.name || "unknown",
+      },
+    };
+  }
+  return normalized;
+}
+
+// ============================================================================
+// CRS Fetch Wrapper
+// ============================================================================
+
+/**
+ * Extract tools from request body for stream transformation
+ */
+function extractToolsFromBody(body: BodyInit | null | undefined): Tool[] {
+  if (!body) return [];
+
+  try {
+    const bodyStr =
+      typeof body === "string" ? body : new TextDecoder().decode(body as ArrayBuffer);
+    const bodyJson = JSON.parse(bodyStr) as { tools?: Tool[] };
+    return Array.isArray(bodyJson.tools) ? bodyJson.tools : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Build request headers from input and init
+ */
+function buildRequestHeaders(
+  input: RequestInfo | URL,
+  init: RequestInit | undefined,
+  apiKey: string
+): Headers {
+  const headers = new Headers();
+
+  // Copy headers from input if it's a Request
+  if (input instanceof Request) {
+    input.headers.forEach((value, key) => headers.set(key, value));
+  }
+
+  // Copy headers from init
+  if (init?.headers) {
+    const initHeaders = init.headers;
+    if (initHeaders instanceof Headers) {
+      initHeaders.forEach((value, key) => headers.set(key, value));
+    } else if (Array.isArray(initHeaders)) {
+      for (const [key, value] of initHeaders) {
+        if (value !== undefined) headers.set(key, String(value));
+      }
+    } else {
+      for (const [key, value] of Object.entries(
+        initHeaders as Record<string, string>
+      )) {
+        if (value !== undefined) headers.set(key, String(value));
+      }
+    }
+  }
+
+  // Set auth and required headers
+  headers.set("x-api-key", apiKey);
+  if (!headers.has("anthropic-version")) {
+    headers.set("anthropic-version", "2023-06-01");
+  }
+
+  return headers;
+}
+
+/**
+ * Ensure URL has /v1/ in the path
+ */
+function normalizeApiUrl(input: RequestInfo | URL): string {
+  const url = input instanceof Request ? input.url : String(input);
+  const urlObj = new URL(url);
+
+  if (!urlObj.pathname.includes("/v1/")) {
+    if (urlObj.pathname.includes("/api/")) {
+      urlObj.pathname = urlObj.pathname.replace("/api/", "/api/v1/");
+    } else {
+      urlObj.pathname = urlObj.pathname.replace(/^\/?/, "/v1/");
+    }
+  }
+
+  return urlObj.toString();
+}
+
+/**
+ * Transform a streaming response through the SSE normalizer
+ */
+function transformStreamingResponse(response: Response, tools: Tool[]): Response {
+  const reader = response.body!.getReader();
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const transformStream = createSSETransformStream(tools);
+  const writer = transformStream.writable.getWriter();
+
+  // Pipe response through transform stream
+  (async () => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          await writer.close();
+          break;
+        }
+        await writer.write(decoder.decode(value, { stream: true }));
+      }
+    } catch (error) {
+      await writer.abort(error);
+    }
+  })();
+
+  const transformedBody = transformStream.readable.pipeThrough(
+    new TransformStream<string, Uint8Array>({
+      transform(chunk, controller) {
+        controller.enqueue(encoder.encode(chunk));
+      },
+    })
+  );
+
+  return new Response(transformedBody, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  });
+}
+
+/**
+ * Transform a non-streaming JSON response
+ */
+async function transformJsonResponse(response: Response): Promise<Response> {
+  try {
+    const text = await response.text();
+    const data = JSON.parse(text) as { model?: string };
+
+    if (data.model?.includes("us.anthropic.")) {
+      data.model = mapBedrockModelId(data.model);
+    }
+
+    return new Response(JSON.stringify(data), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+    });
+  } catch {
+    return response;
+  }
+}
+
+type GetAuthFn = () => Promise<{ key: string } | null>;
+
+/**
+ * Creates a custom fetch function that handles CRS-specific transformations
+ */
+function createCRSFetch(
+  getAuth: GetAuthFn
+): typeof fetch {
+  return async function crsFetch(
+    input: RequestInfo | URL,
+    init?: RequestInit
+  ): Promise<Response> {
+    const auth = await getAuth();
+    if (!auth?.key) {
+      return fetch(input, init);
+    }
+
+    const url = normalizeApiUrl(input);
+    const headers = buildRequestHeaders(input, init, auth.key);
+    const tools = extractToolsFromBody(init?.body);
+
+    const response = await fetch(url, { ...init, headers });
+
+    const contentType = response.headers.get("content-type") || "";
+
+    if (contentType.includes("text/event-stream") && response.body) {
+      return transformStreamingResponse(response, tools);
+    }
+
+    if (contentType.includes("application/json")) {
+      return transformJsonResponse(response);
+    }
+
+    return response;
+  };
+}
+
+// ============================================================================
+// Plugin Export
+// ============================================================================
+
+/**
+ * CRS Auth Plugin for OpenCode
+ */
+export const CRSAuthPlugin: Plugin = async () => {
+  return {
+    auth: {
+      provider: PROVIDER_ID,
+
+      async loader(
+        getAuth: () => Promise<Auth>,
+        provider: Provider
+      ) {
+        let baseURL = provider?.options?.baseURL as string | undefined;
+        if (baseURL && !baseURL.includes("/v1")) {
+          baseURL = baseURL.replace(/\/?$/, "/v1/");
+        }
+
+        let apiKey = provider?.options?.apiKey as string | undefined;
+        if (!apiKey) {
+          const auth = await getAuth();
+          apiKey = auth?.type === "api" ? auth.key : undefined;
+        }
+
+        if (!apiKey) {
+          return {};
+        }
+
+        return {
+          apiKey: "",
+          baseURL,
+          fetch: createCRSFetch(() => Promise.resolve({ key: apiKey! })),
+        };
+      },
+
+      methods: [
+        {
+          label: "Enter CRS API Key",
+          type: "api" as const,
+          prompts: [
+            {
+              type: "text" as const,
+              message: "Enter your CRS API Key (cr_...)",
+              key: "apiKey",
+            },
+          ],
+        },
+      ],
+    },
+  };
+};