opencode-crs-bedrock 1.0.8 → 2.0.0

package/README.md

@@ -2,26 +2,10 @@
 
 OpenCode plugin for FeedMob CRS (Claude Relay Service) proxy to AWS Bedrock Anthropic models.
 
-## Why This Plugin?
-
-When using CRS to proxy requests to AWS Bedrock's Anthropic models, the response format differs from the native Anthropic API in ways that break `@ai-sdk/anthropic`:
-
-| Issue | What CRS/Bedrock Returns | What SDK Expects |
-|-------|--------------------------|------------------|
-| Model IDs | `us.anthropic.claude-sonnet-4-20250514-v1:0` | `claude-sonnet-4-20250514` |
-| Message start | `{type: "message", ...}` | `{type: "message_start", message: {...}}` |
-| Tool calls | Missing `content_block_start` events | `content_block_start` with tool name and ID |
-| Block close | Missing `content_block_stop` events | `content_block_stop` before `message_delta` |
-
-This plugin transforms the CRS response stream to match what the Anthropic SDK expects.
-
 ## Features
 
-- **SSE Stream Transformation** - Fixes discriminator validation errors
-- **Tool Name Inference** - Buffers tool call deltas and infers correct tool name from parameters
-- **Event Injection** - Adds missing `content_block_start` and `content_block_stop` events
-- **Model ID Mapping** - Converts Bedrock model IDs to standard Anthropic format
-- **API Key Auth** - Uses `x-api-key` header (bypasses SDK's `sk-ant-` validation)
+- **URL Rewriting** - Routes requests to the CRS endpoint
+- **API Key Auth** - Uses `x-api-key` header for authentication
 
 ## Installation
 
@@ -89,7 +73,7 @@ When prompted:
 2. Enter provider id: **`crs`**
 3. Enter your CRS API key (starts with `cr_`)
 
-Your credentials will be securely stored and the plugin will automatically configure the custom fetch handler for CRS/Bedrock compatibility
+Your credentials will be securely stored and the plugin will automatically configure the custom fetch handler for CRS authentication.
 
 ## Usage
 
@@ -127,51 +111,14 @@ All models support:
 - **Input**: text, images, PDF documents
 - **Output**: text
 
-## Supported Models
-
-Models available through CRS/Bedrock:
-
-| Model ID | Bedrock ID |
-|----------|------------|
-| `claude-sonnet-4-20250514` | `us.anthropic.claude-sonnet-4-20250514-v1:0` |
-| `claude-opus-4-20250514` | `us.anthropic.claude-opus-4-20250514-v1:0` |
-| `claude-opus-4-5-20251101` | `us.anthropic.claude-opus-4-5-20251101-v1:0` |
-| `claude-haiku-4-5-20251001` | `us.anthropic.claude-haiku-4-5-20251001-v1:0` |
-| `claude-sonnet-4-5-20250929` | `us.anthropic.claude-sonnet-4-5-20250929-v1:0` |
-| `claude-3-5-sonnet-20241022` | `us.anthropic.claude-3-5-sonnet-20241022-v2:0` |
-| `claude-3-5-haiku-20241022` | `us.anthropic.claude-3-5-haiku-20241022-v1:0` |
-| `claude-3-opus-20240229` | `us.anthropic.claude-3-opus-20240229-v1:0` |
-
 ## Debugging
 
-Enable debug logging to see SSE transformation details:
+Enable debug logging to see request details:
 
 ```bash
-CRS_DEBUG_SSE=true opencode
-```
-
-Example output:
-```
-[CRS-SSE] Event: message_start Data: {"type":"message","id":"msg_123"...}
-[CRS-SSE] Event: content_block_delta Data: {"index":1,"delta":{"type":"input_json_delta"...}}
-[CRS-SSE] Buffering tool delta, accumulated: {"query": "bitcoin price"
-[CRS-SSE] Flushing pending tool block 1 with inferred name: websearch
+CRS_DEBUG=true opencode
 ```
 
-## How Tool Name Inference Works
-
-CRS/Bedrock doesn't send `content_block_start` for tool calls, so the plugin:
-
-1. **Detects tool deltas** - When `input_json_delta` arrives without a prior `content_block_start`
-2. **Buffers deltas** - Accumulates the JSON until complete
-3. **Infers tool name** - Matches accumulated JSON keys against tool schemas
-4. **Emits events** - Sends `content_block_start` with inferred name, then buffered deltas
-
-The inference scores each tool by:
-- +1 for each matching parameter key
-- -1 for each unknown key
-- +10 bonus if all required parameters present
-
 ## Troubleshooting
 
 ### Authentication Issues
@@ -191,14 +138,6 @@ Make sure to:
 - Enter provider id: **`crs`**
 - Enter your CRS API key (starts with `cr_`)
 
-### "Invalid input: expected array, received undefined"
-
-This error means tool name inference failed. Enable debug logging to see which tool was inferred:
-
-```bash
-CRS_DEBUG_SSE=true opencode run -m crs/claude-sonnet-4-5 "test"
-```
-
 ### Connection Issues
 
 1. Verify your credentials are stored:
@@ -210,7 +149,7 @@ CRS_DEBUG_SSE=true opencode run -m crs/claude-sonnet-4-5 "test"
 
 3. Enable debug logging to see request details:
    ```bash
-   CRS_DEBUG_SSE=true opencode run -m crs/claude-sonnet-4-5 "test"
+   CRS_DEBUG=true opencode run -m crs/claude-sonnet-4-5 "test"
    ```
 
 ## Local Development

package/index.ts

@@ -5,11 +5,8 @@
  * for AWS Bedrock Anthropic models.
  *
  * Handles:
+ * - URL rewriting to CRS endpoint
  * - 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, PluginInput } from "@opencode-ai/plugin";
@@ -38,867 +35,24 @@ interface PluginContext {
   client: PluginClient;
 }
 
-// ============================================================================
-// 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";
+const DEBUG = process.env.CRS_DEBUG === "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));
+  if (DEBUG) {
+    console.error("[CRS]", ...args);
   }
-  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",
-  "us.anthropic.claude-opus-4-5-20251101-v1:0": "claude-opus-4-5-20251101",
-  "us.anthropic.claude-haiku-4-5-20251001-v1:0": "claude-haiku-4-5-20251001",
-  "us.anthropic.claude-sonnet-4-5-20250929-v1:0": "claude-sonnet-4-5-20250929",
-};
-
-/**
- * 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);
-      
-      // If we couldn't infer a tool name, emit a helpful text block instead of a broken tool_use
-      if (!inferredName) {
-        debugLog(
-          "Could not infer tool name for block",
-          blockIndex,
-          "- converting to text with available tools list"
-        );
-        
-        const availableTools = Array.from(this.toolSchemas.keys()).join(", ");
-        const helpText = `Tool inference failed. The model attempted to call a tool but the tool name could not be determined from the input parameters. Available tools: ${availableTools}. Please specify which tool you want to use.`;
-        
-        // Emit as a text block instead of a tool_use
-        emitSSEEvent(controller, "content_block_start", {
-          type: "content_block_start",
-          index: blockIndex,
-          content_block: {
-            type: "text",
-            text: helpText,
-          },
-        });
-        
-        emitSSEEvent(controller, "content_block_stop", {
-          type: "content_block_stop",
-          index: blockIndex,
-        });
-        
-        continue;
-      }
-      
-      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
  */
@@ -960,95 +114,19 @@ function normalizeApiUrl(input: RequestInfo | URL): string {
 }
 
 /**
- * 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
+ * Creates a custom fetch function that handles CRS URL rewriting and API key injection
  */
-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;
-  }
-}
-
-/**
- * Creates a custom fetch function that handles CRS-specific transformations
- */
-function createCRSFetch(
-  authKey: string
-): typeof fetch {
+function createCRSFetch(authKey: string): typeof fetch {
   return async function crsFetch(
     input: RequestInfo | URL,
     init?: RequestInit
   ): Promise<Response> {
     const url = normalizeApiUrl(input);
     const headers = buildRequestHeaders(input, init, authKey);
-    const tools = extractToolsFromBody(init?.body);
 
-    const response = await fetch(url, { ...init, headers });
+    debugLog("Fetching:", url);
 
-    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;
+    return fetch(url, { ...init, headers });
   };
 }
 
@@ -1071,13 +149,18 @@ export const CRSAuthPlugin: Plugin = async ({ client }: PluginContext) => {
         _provider: Provider
       ): Promise<LoaderResult | Record<string, unknown>> => {
         debugLog("CRS auth loader called");
-        
+
         const auth = await getAuth();
         // OpenCode stores API keys as 'key' field when type is 'api'
         const apiKey = auth.key as string | undefined;
-        const baseURL = process.env.ANTHROPIC_BASE_URL || "https://crs.tonob.net/api";
+        const baseURL =
+          process.env.ANTHROPIC_BASE_URL || "https://crs.tonob.net/api";
 
-        debugLog("Auth details:", { hasApiKey: !!apiKey, baseURL, authKeys: Object.keys(auth) });
+        debugLog("Auth details:", {
+          hasApiKey: !!apiKey,
+          baseURL,
+          authKeys: Object.keys(auth),
+        });
 
         if (!apiKey) {
           debugLog("No API key found, returning baseURL only");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-crs-bedrock",
-  "version": "1.0.8",
+  "version": "2.0.0",
   "description": "OpenCode plugin for FeedMob CRS proxy to AWS Bedrock Anthropic models",
   "type": "module",
   "main": "index.ts",