opencode-crs-bedrock 1.0.5 → 1.0.7

package/README.md

@@ -25,54 +25,33 @@ This plugin transforms the CRS response stream to match what the Anthropic SDK e
 
 ## Installation
 
-### Local Development
+```bash
+npm install -g opencode-crs-bedrock
+```
 
-Reference directly in your OpenCode config:
+Or add to your OpenCode config to auto-install:
 
 ```json
 {
-  "plugin": [
-    "file:///path/to/opencode-crs-bedrock"
-  ]
+  "plugin": ["opencode-crs-bedrock@latest"]
 }
 ```
 
-### From npm (when published)
-
-```bash
-npm install -g opencode-crs-bedrock
-```
-
-## Configuration
-
-> **Note**: Both `apiKey` and `baseURL` are optional. You can configure them via environment variables, use `opencode auth login crs` for interactive setup, or configure them directly in the config file.
-
-### Option 1: Using Environment Variables (Recommended)
-
-Set environment variables for automatic configuration:
-
-```bash
-export ANTHROPIC_BASE_URL=https://your-crs-endpoint.com/api
-export ANTHROPIC_AUTH_TOKEN=cr_your_api_key_here
-```
+## Quick Start
 
-Add to your shell profile (`~/.bashrc`, `~/.zshrc`) to persist.
+### Step 1: Configure OpenCode
 
-Then create `opencode.json` in your project or `~/.config/opencode/opencode.json`:
+Create or edit `opencode.json` in your project root or `~/.config/opencode/opencode.json`:
 
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
   "plugin": [
-    "opencode-crs-bedrock"
+    "opencode-crs-bedrock@latest"
   ],
   "provider": {
     "crs": {
       "npm": "@ai-sdk/anthropic",
-      "options": {
-        "baseURL": "{env:ANTHROPIC_BASE_URL}",
-        "apiKey": "{env:ANTHROPIC_AUTH_TOKEN}"
-      },
       "models": {
         "claude-opus-4-5": {
           "name": "Opus 4.5 [CRS]",
@@ -97,64 +76,28 @@ Then create `opencode.json` in your project or `~/.config/opencode/opencode.json
 }
 ```
 
-### Option 2: Using OpenCode Auth (Interactive)
+### Step 2: Authenticate
 
-The plugin supports interactive authentication. First, create the config **without** `baseURL` or `apiKey`:
-
-```json
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugin": [
-    "opencode-crs-bedrock"
-  ],
-  "provider": {
-    "crs": {
-      "npm": "@ai-sdk/anthropic",
-      "models": {
-        "claude-sonnet-4-5": {
-          "name": "Sonnet 4.5 [CRS]",
-          "modalities": { "input": ["text", "image", "pdf"], "output": ["text"] }
-        }
-      }
-    }
-  }
-}
-```
-
-Then run the auth login command to store your credentials:
+Run the OpenCode auth login command:
 
 ```bash
-opencode auth login crs
+opencode auth login
 ```
 
-OpenCode will prompt you to enter your CRS API key, which will be securely stored. The plugin's auth loader will then be triggered automatically to configure the custom fetch handler for CRS/Bedrock compatibility.
+When prompted:
+1. Select **Other provider**
+2. Enter provider id: **`crs`**
+3. Enter your CRS API key (starts with `cr_`)
 
-### Option 3: Direct Configuration (No Environment Variables)
+Your credentials will be securely stored and the plugin will automatically configure the custom fetch handler for CRS/Bedrock compatibility
 
-You can also hardcode credentials directly in the config (not recommended for shared configs):
-
-```json
-{
-  "provider": {
-    "crs": {
-      "npm": "@ai-sdk/anthropic",
-      "options": {
-        "baseURL": "https://your-crs-endpoint.com/api",
-        "apiKey": "cr_your_api_key_here"
-      },
-      "models": { /* ... */ }
-    }
-  }
-}
-```
-
-### Using the Model
+## Usage
 
 ```bash
 # Interactive mode
 opencode
 
-# Or direct run with default model
+# Or direct run with a specific model
 opencode run -m crs/claude-sonnet-4-5 "Hello, world!"
 
 # Use with thinking budget variants
@@ -192,6 +135,9 @@ Models available through CRS/Bedrock:
 |----------|------------|
 | `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` |
@@ -228,44 +174,58 @@ The inference scores each tool by:
 
 ## Troubleshooting
 
-### "Invalid input: expected array, received undefined"
+### Authentication Issues
 
-This error means tool name inference failed. Enable debug logging to see which tool was inferred.
+**Check stored credentials:**
+```bash
+opencode auth list
+```
 
-### API Key Format
+If your CRS credentials aren't listed, run the authentication step again:
+```bash
+opencode auth login
+```
 
-CRS API keys start with `cr_`. The plugin uses the `x-api-key` header instead of the standard Anthropic auth.
+Make sure to:
+- Select **Other provider**
+- Enter provider id: **`crs`**
+- Enter your CRS API key (starts with `cr_`)
 
-### Connection Issues
+### "Invalid input: expected array, received undefined"
+
+This error means tool name inference failed. Enable debug logging to see which tool was inferred:
 
-1. Check your authentication method:
-   - **Environment variables**: Verify they're set:
-     ```bash
-     echo $ANTHROPIC_BASE_URL
-     echo $ANTHROPIC_AUTH_TOKEN
-     ```
-   - **OpenCode auth**: Run `opencode auth list` to see stored credentials
-   - **Direct config**: Check your `opencode.json` has correct values
+```bash
+CRS_DEBUG_SSE=true opencode run -m crs/claude-sonnet-4-5 "test"
+```
+
+### Connection Issues
 
-2. Test the endpoint (if using environment variables):
+1. Verify your credentials are stored:
    ```bash
-   curl -H "x-api-key: $ANTHROPIC_AUTH_TOKEN" "$ANTHROPIC_BASE_URL/v1/messages"
+   opencode auth list
    ```
 
-3. Enable debug logging:
+2. Check your `opencode.json` has the correct provider configuration (see Quick Start above)
+
+3. Enable debug logging to see request details:
    ```bash
    CRS_DEBUG_SSE=true opencode run -m crs/claude-sonnet-4-5 "test"
    ```
 
-### Missing API Key or Base URL
+## Local Development
 
-Both `apiKey` and `baseURL` are **optional** in the plugin:
+For contributors working on the plugin itself:
 
-- If **not provided via environment variables or config**, use `opencode auth login crs` to store credentials interactively
-- The plugin defaults to `https://crs.tonob.net/api` if no `baseURL` is specified
-- You can mix and match: set `baseURL` in config and use `opencode auth login` for the `apiKey`, or vice versa
+```json
+{
+  "plugin": [
+    "file:///path/to/opencode-crs-bedrock"
+  ]
+}
+```
 
-**Important**: The plugin's custom fetch handler (which fixes CRS/Bedrock compatibility issues) is only activated when using `opencode auth login` or environment variables. If you hardcode credentials directly in the config, the auth loader may not be triggered.
+Reference the local directory in your OpenCode config for live development.
 
 ## License
 

package/index.ts

@@ -335,6 +335,9 @@ const BEDROCK_MODEL_MAPPINGS: Record<string, string> = {
   "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",
 };
 
 /**
@@ -1070,10 +1073,11 @@ export const CRSAuthPlugin: Plugin = async ({ client }: PluginContext) => {
         debugLog("CRS auth loader called");
         
         const auth = await getAuth();
-        const apiKey = auth.apiKey as string | undefined;
+        // OpenCode stores API keys as 'key' field when type is 'api'
+        const apiKey = (auth.key || auth.apiKey) as string | undefined;
         const baseURL = (auth.baseURL as string | undefined) || process.env.ANTHROPIC_BASE_URL || "https://crs.tonob.net/api";
 
-        debugLog("Auth details:", { hasApiKey: !!apiKey, baseURL });
+        debugLog("Auth details:", { hasApiKey: !!apiKey, baseURL, authKeys: Object.keys(auth) });
 
         if (!apiKey) {
           debugLog("No API key found, returning baseURL only");

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "opencode-crs-bedrock",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "OpenCode plugin for FeedMob CRS proxy to AWS Bedrock Anthropic models",
   "type": "module",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "index.ts",
+  "module": "index.ts",
   "files": [
-    "dist",
     "index.ts"
   ],
   "keywords": [

package/dist/index.js

@@ -1,555 +0,0 @@
-// index.ts
-var PROVIDER_ID = "crs";
-var VALID_SSE_EVENT_TYPES = new Set([
-  "message_start",
-  "content_block_start",
-  "content_block_delta",
-  "content_block_stop",
-  "message_delta",
-  "message_stop",
-  "ping",
-  "error"
-]);
-var DEBUG_SSE = process.env.CRS_DEBUG_SSE === "true";
-function debugLog(...args) {
-  if (DEBUG_SSE) {
-    console.error("[CRS-SSE]", ...args);
-  }
-}
-function generateToolUseId() {
-  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;
-}
-function emitSSEEvent(controller, eventType, data) {
-  controller.enqueue(`event: ${eventType}
-`);
-  controller.enqueue(`data: ${JSON.stringify(data)}
-`);
-  controller.enqueue(`
-`);
-}
-function emitEventHeader(controller, eventType) {
-  controller.enqueue(`event: ${eventType}
-`);
-}
-function buildToolSchemas(tools) {
-  const schemas = new Map;
-  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;
-}
-function inferToolName(jsonStr, toolSchemas) {
-  try {
-    const input = JSON.parse(jsonStr);
-    const inputKeys = new Set(Object.keys(input));
-    let bestMatch = null;
-    let bestScore = -1;
-    for (const [toolName, schema] of toolSchemas) {
-      const schemaKeys = new Set(Object.keys(schema.params));
-      let matchCount = 0;
-      let mismatchCount = 0;
-      for (const key of inputKeys) {
-        if (schemaKeys.has(key)) {
-          matchCount++;
-        } else {
-          mismatchCount++;
-        }
-      }
-      let hasAllRequired = true;
-      for (const req of schema.required) {
-        if (!inputKeys.has(req)) {
-          hasAllRequired = false;
-          break;
-        }
-      }
-      const score = matchCount - mismatchCount + (hasAllRequired ? 10 : 0);
-      if (score > bestScore) {
-        bestScore = score;
-        bestMatch = toolName;
-      }
-    }
-    return bestMatch;
-  } catch {
-    return null;
-  }
-}
-var BEDROCK_MODEL_MAPPINGS = {
-  "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"
-};
-function mapBedrockModelId(bedrockModelId) {
-  if (BEDROCK_MODEL_MAPPINGS[bedrockModelId]) {
-    return BEDROCK_MODEL_MAPPINGS[bedrockModelId];
-  }
-  const match = bedrockModelId.match(/us\.anthropic\.(.+?)-v\d+:\d+$/);
-  if (match) {
-    return match[1];
-  }
-  return bedrockModelId;
-}
-
-class SSETransformState {
-  toolSchemas;
-  buffer;
-  currentEventType;
-  startedBlocks;
-  pendingToolBlocks;
-  constructor(toolSchemas) {
-    this.toolSchemas = toolSchemas;
-    this.buffer = "";
-    this.currentEventType = null;
-    this.startedBlocks = new Map;
-    this.pendingToolBlocks = new Map;
-  }
-  trackBlockStart(index, contentBlock) {
-    const blockType = contentBlock?.type || "text";
-    if (blockType === "tool_use") {
-      const toolBlock = contentBlock;
-      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 });
-    }
-  }
-  bufferToolDelta(index, eventType, data, partialJson) {
-    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);
-  }
-  hasPendingToolBlock(index) {
-    return this.pendingToolBlocks.has(index);
-  }
-  flushPendingToolBlocks(controller) {
-    for (const [blockIndex, pending] of this.pendingToolBlocks) {
-      const inferredName = inferToolName(pending.inputBuffer, this.toolSchemas);
-      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.`;
-        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);
-      emitSSEEvent(controller, "content_block_start", {
-        type: "content_block_start",
-        index: blockIndex,
-        content_block: {
-          type: "tool_use",
-          id: pending.toolId,
-          name: inferredName,
-          input: {}
-        }
-      });
-      for (const buffered of pending.deltas) {
-        emitSSEEvent(controller, buffered.event, {
-          type: buffered.event,
-          ...buffered.data
-        });
-      }
-      this.startedBlocks.set(blockIndex, {
-        type: "tool_use",
-        id: pending.toolId,
-        name: inferredName,
-        inputBuffer: pending.inputBuffer,
-        emitted: true
-      });
-    }
-    this.pendingToolBlocks.clear();
-  }
-  closeAllBlocks(controller) {
-    for (const [blockIndex] of this.startedBlocks) {
-      emitSSEEvent(controller, "content_block_stop", {
-        type: "content_block_stop",
-        index: blockIndex
-      });
-    }
-    this.startedBlocks.clear();
-  }
-}
-function createSSETransformStream(tools = []) {
-  const state = new SSETransformState(buildToolSchemas(tools));
-  return new TransformStream({
-    transform(chunk, controller) {
-      state.buffer += chunk;
-      const lines = state.buffer.split(`
-`);
-      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);
-      }
-    }
-  });
-}
-function processSSELine(line, state, controller) {
-  const trimmedLine = line.trim();
-  if (trimmedLine === "") {
-    controller.enqueue(`
-`);
-    state.currentEventType = null;
-    return;
-  }
-  if (trimmedLine.startsWith(":")) {
-    controller.enqueue(line + `
-`);
-    return;
-  }
-  if (trimmedLine.startsWith("event:")) {
-    const eventType = trimmedLine.slice(6).trim();
-    if (!VALID_SSE_EVENT_TYPES.has(eventType)) {
-      state.currentEventType = null;
-      return "skip";
-    }
-    state.currentEventType = eventType;
-    controller.enqueue(line + `
-`);
-    return;
-  }
-  if (trimmedLine.startsWith("data:")) {
-    return processDataLine(trimmedLine, line, state, controller);
-  }
-  controller.enqueue(line + `
-`);
-}
-function processDataLine(trimmedLine, originalLine, state, controller) {
-  const dataContent = trimmedLine.slice(5).trim();
-  if (dataContent === "[DONE]") {
-    controller.enqueue(originalLine + `
-`);
-    return;
-  }
-  if (state.currentEventType === null) {
-    return "skip";
-  }
-  try {
-    const data = JSON.parse(dataContent);
-    debugLog("Event:", state.currentEventType, "Data:", JSON.stringify(data).slice(0, 500));
-    const shouldSkip = handleEventData(data, state, controller);
-    if (shouldSkip)
-      return "skip";
-    const normalized = normalizeEventData(data, state.currentEventType);
-    controller.enqueue(`data: ${JSON.stringify(normalized)}
-`);
-  } catch {
-    controller.enqueue(originalLine + `
-`);
-  }
-}
-function handleEventData(data, state, controller) {
-  const eventType = state.currentEventType;
-  if (eventType === "content_block_start" && typeof data.index === "number") {
-    const blockData = data;
-    state.trackBlockStart(blockData.index, blockData.content_block);
-    return false;
-  }
-  if (eventType === "content_block_delta" && typeof data.index === "number") {
-    return handleContentBlockDelta(data, state, controller);
-  }
-  if (eventType === "content_block_stop" && typeof data.index === "number") {
-    state.startedBlocks.delete(data.index);
-    return false;
-  }
-  if (eventType === "message_delta") {
-    state.flushPendingToolBlocks(controller);
-    if (state.startedBlocks.size > 0) {
-      state.closeAllBlocks(controller);
-    }
-    emitEventHeader(controller, eventType);
-    return false;
-  }
-  return false;
-}
-function handleContentBlockDelta(data, state, controller) {
-  const index = data.index;
-  const deltaType = data.delta?.type;
-  if (!state.startedBlocks.has(index)) {
-    if (deltaType === "input_json_delta") {
-      const jsonDelta = data.delta;
-      state.bufferToolDelta(index, state.currentEventType, data, jsonDelta.partial_json || "");
-      return true;
-    } else {
-      injectTextBlockStart(index, state, controller);
-    }
-  } else if (deltaType === "input_json_delta" && state.hasPendingToolBlock(index)) {
-    const jsonDelta = data.delta;
-    state.bufferToolDelta(index, state.currentEventType, data, jsonDelta.partial_json || "");
-    return true;
-  } else if (deltaType === "input_json_delta") {
-    const blockInfo = state.startedBlocks.get(index);
-    if (blockInfo?.type === "tool_use") {
-      const jsonDelta = data.delta;
-      blockInfo.inputBuffer = (blockInfo.inputBuffer || "") + (jsonDelta.partial_json || "");
-    }
-  }
-  fixDeltaTypeMismatch(data, state.startedBlocks.get(index));
-  return false;
-}
-function injectTextBlockStart(index, state, controller) {
-  state.startedBlocks.set(index, { type: "text", emitted: true });
-  emitSSEEvent(controller, "content_block_start", {
-    type: "content_block_start",
-    index,
-    content_block: { type: "text", text: "" }
-  });
-  emitEventHeader(controller, state.currentEventType);
-}
-function fixDeltaTypeMismatch(data, blockInfo) {
-  if (!blockInfo || !data.delta)
-    return;
-  const blockType = blockInfo.type || "text";
-  if (blockType === "tool_use" && data.delta.type === "text_delta") {
-    const textDelta = data.delta;
-    data.delta = {
-      type: "input_json_delta",
-      partial_json: textDelta.text || ""
-    };
-  } else if (blockType === "text" && data.delta.type === "input_json_delta") {
-    const jsonDelta = data.delta;
-    data.delta = {
-      type: "text_delta",
-      text: jsonDelta.partial_json || ""
-    };
-  }
-}
-function normalizeEventData(data, eventType) {
-  const normalized = { ...data };
-  if (!normalized.type) {
-    normalized.type = eventType;
-  }
-  if (eventType === "message_start") {
-    return normalizeMessageStart(data);
-  }
-  if (eventType === "content_block_start") {
-    return normalizeContentBlockStart(normalized);
-  }
-  return normalized;
-}
-function normalizeMessageStart(data) {
-  if (data.type === "message" || !data.message) {
-    const messageData = { ...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 };
-  }
-  if (data.message?.model?.includes("us.anthropic.")) {
-    const normalized = {
-      ...data,
-      message: {
-        ...data.message,
-        model: mapBedrockModelId(data.message.model)
-      }
-    };
-    return normalized;
-  }
-  return data;
-}
-function normalizeContentBlockStart(normalized) {
-  if (!normalized.content_block) {
-    return {
-      ...normalized,
-      content_block: { type: "text", text: "" }
-    };
-  } else if (normalized.content_block.type === "tool_use") {
-    const toolBlock = normalized.content_block;
-    return {
-      ...normalized,
-      content_block: {
-        ...toolBlock,
-        id: toolBlock.id || generateToolUseId(),
-        name: toolBlock.name || "unknown"
-      }
-    };
-  }
-  return normalized;
-}
-function extractToolsFromBody(body) {
-  if (!body)
-    return [];
-  try {
-    const bodyStr = typeof body === "string" ? body : new TextDecoder().decode(body);
-    const bodyJson = JSON.parse(bodyStr);
-    return Array.isArray(bodyJson.tools) ? bodyJson.tools : [];
-  } catch {
-    return [];
-  }
-}
-function buildRequestHeaders(input, init, apiKey) {
-  const headers = new Headers;
-  if (input instanceof Request) {
-    input.headers.forEach((value, key) => headers.set(key, value));
-  }
-  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)) {
-        if (value !== undefined)
-          headers.set(key, String(value));
-      }
-    }
-  }
-  headers.set("x-api-key", apiKey);
-  if (!headers.has("anthropic-version")) {
-    headers.set("anthropic-version", "2023-06-01");
-  }
-  return headers;
-}
-function normalizeApiUrl(input) {
-  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();
-}
-function transformStreamingResponse(response, tools) {
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder;
-  const encoder = new TextEncoder;
-  const transformStream = createSSETransformStream(tools);
-  const writer = transformStream.writable.getWriter();
-  (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({
-    transform(chunk, controller) {
-      controller.enqueue(encoder.encode(chunk));
-    }
-  }));
-  return new Response(transformedBody, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-}
-async function transformJsonResponse(response) {
-  try {
-    const text = await response.text();
-    const data = JSON.parse(text);
-    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;
-  }
-}
-function createCRSFetch(authKey) {
-  return async function crsFetch(input, init) {
-    const url = normalizeApiUrl(input);
-    const headers = buildRequestHeaders(input, init, authKey);
-    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;
-  };
-}
-var CRSAuthPlugin = async ({ client }) => {
-  debugLog("CRS Bedrock plugin initializing...");
-  return {
-    auth: {
-      provider: PROVIDER_ID,
-      loader: async (getAuth, _provider) => {
-        debugLog("CRS auth loader called");
-        const auth = await getAuth();
-        const apiKey = auth.apiKey;
-        const baseURL = auth.baseURL || process.env.ANTHROPIC_BASE_URL || "https://crs.tonob.net/api";
-        debugLog("Auth details:", { hasApiKey: !!apiKey, baseURL });
-        if (!apiKey) {
-          debugLog("No API key found, returning baseURL only");
-          return { baseURL };
-        }
-        debugLog("Returning full config with custom fetch");
-        return {
-          apiKey,
-          baseURL,
-          fetch: createCRSFetch(apiKey)
-        };
-      },
-      methods: [
-        {
-          label: "Enter CRS API Key",
-          type: "api"
-        }
-      ]
-    }
-  };
-};
-var opencode_crs_bedrock_default = CRSAuthPlugin;
-export {
-  opencode_crs_bedrock_default as default,
-  CRSAuthPlugin
-};