opencode-crs-bedrock 1.0.1 → 1.0.3

package/README.md

@@ -45,7 +45,11 @@ npm install -g opencode-crs-bedrock
 
 ## Configuration
 
-### 1. Set Environment Variables
+> **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
@@ -54,9 +58,7 @@ export ANTHROPIC_AUTH_TOKEN=cr_your_api_key_here
 
 Add to your shell profile (`~/.bashrc`, `~/.zshrc`) to persist.
 
-### 2. Create OpenCode Config
-
-Create `opencode.json` in your project or `~/.config/opencode/opencode.json` globally:
+Then create `opencode.json` in your project or `~/.config/opencode/opencode.json`:
 
 ```json
 {
@@ -95,7 +97,58 @@ Create `opencode.json` in your project or `~/.config/opencode/opencode.json` glo
 }
 ```
 
-### 3. Use the Model
+### Option 2: Using OpenCode Auth (Interactive)
+
+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:
+
+```bash
+opencode auth login crs
+```
+
+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.
+
+### Option 3: Direct Configuration (No Environment Variables)
+
+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
 
 ```bash
 # Interactive mode
@@ -185,13 +238,16 @@ CRS API keys start with `cr_`. The plugin uses the `x-api-key` header instead of
 
 ### Connection Issues
 
-1. Verify environment variables:
-   ```bash
-   echo $ANTHROPIC_BASE_URL
-   echo $ANTHROPIC_AUTH_TOKEN
-   ```
+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
 
-2. Test the endpoint:
+2. Test the endpoint (if using environment variables):
    ```bash
    curl -H "x-api-key: $ANTHROPIC_AUTH_TOKEN" "$ANTHROPIC_BASE_URL/v1/messages"
    ```
@@ -201,6 +257,16 @@ CRS API keys start with `cr_`. The plugin uses the `x-api-key` header instead of
    CRS_DEBUG_SSE=true opencode run -m crs/claude-sonnet-4-5 "test"
    ```
 
+### Missing API Key or Base URL
+
+Both `apiKey` and `baseURL` are **optional** in the plugin:
+
+- 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
+
+**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.
+
 ## License
 
 MIT

package/index.ts

@@ -12,8 +12,31 @@
  * - Bedrock model ID mapping to standard Anthropic format
  */
 
-import type { Plugin } from "@opencode-ai/plugin";
-import type { Auth, Provider } from "@opencode-ai/sdk";
+import type { Plugin, PluginInput } from "@opencode-ai/plugin";
+import type { Provider } from "@opencode-ai/sdk";
+
+// ============================================================================
+// Type Definitions for Plugin
+// ============================================================================
+
+interface AuthDetails {
+  type?: string;
+  [key: string]: unknown;
+}
+
+type GetAuth = () => Promise<AuthDetails>;
+
+interface LoaderResult {
+  apiKey?: string;
+  baseURL?: string;
+  fetch: typeof fetch;
+}
+
+type PluginClient = PluginInput["client"];
+
+interface PluginContext {
+  client: PluginClient;
+}
 
 // ============================================================================
 // Type Definitions
@@ -967,25 +990,18 @@ async function transformJsonResponse(response: Response): Promise<Response> {
   }
 }
 
-type GetAuthFn = () => Promise<{ key: string } | null>;
-
 /**
  * Creates a custom fetch function that handles CRS-specific transformations
  */
 function createCRSFetch(
-  getAuth: GetAuthFn
+  authKey: string
 ): 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 headers = buildRequestHeaders(input, init, authKey);
     const tools = extractToolsFromBody(init?.body);
 
     const response = await fetch(url, { ...init, headers });
@@ -1011,45 +1027,47 @@ function createCRSFetch(
 /**
  * CRS Auth Plugin for OpenCode
  */
-export const CRSAuthPlugin: Plugin = async () => {
+export const CRSAuthPlugin: Plugin = async ({ client }: PluginContext) => {
+  debugLog("CRS Bedrock plugin initializing...");
+
   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/");
-        }
+      loader: async (
+        getAuth: GetAuth,
+        _provider: Provider
+      ): Promise<LoaderResult | Record<string, unknown>> => {
+        debugLog("CRS auth loader called");
+        
+        const auth = await getAuth();
+        const apiKey = auth.apiKey as string | undefined;
+        const baseURL = (auth.baseURL as string | undefined) || process.env.ANTHROPIC_BASE_URL || "https://crs.tonob.net/api";
 
-        let apiKey = provider?.options?.apiKey as string | undefined;
-        if (!apiKey) {
-          const auth = await getAuth();
-          apiKey = auth?.type === "api" ? auth.key : undefined;
-        }
+        debugLog("Auth details:", { hasApiKey: !!apiKey, baseURL });
 
         if (!apiKey) {
-          return {};
+          debugLog("No API key found, returning baseURL only");
+          return { baseURL };
         }
 
+        debugLog("Returning full config with custom fetch");
+
         return {
-          apiKey: "",
+          apiKey,
           baseURL,
-          fetch: createCRSFetch(() => Promise.resolve({ key: apiKey! })),
+          fetch: createCRSFetch(apiKey),
         };
       },
 
       methods: [
         {
           label: "Enter CRS API Key",
-          type: "api" as const,
+          type: "api",
           prompts: [
             {
-              type: "text" as const,
-              message: "Enter your CRS API Key (cr_...)",
+              type: "text",
+              message: "Enter your CRS API Key",
               key: "apiKey",
             },
           ],
@@ -1058,3 +1076,4 @@ export const CRSAuthPlugin: Plugin = async () => {
     },
   };
 };
+

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "opencode-crs-bedrock",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "OpenCode plugin for FeedMob CRS proxy to AWS Bedrock Anthropic models",
   "type": "module",
-  "main": "index.ts",
+  "module": "index.ts",
+  "files": [
+    "index.ts"
+  ],
   "keywords": [
     "opencode",
     "plugin",
@@ -12,8 +15,11 @@
     "claude",
     "anthropic"
   ],
-  "license": "MIT",
   "dependencies": {
-    "@opencode-ai/plugin": "*"
+    "@opencode-ai/sdk": "^1.1.23 ",
+    "@opencode-ai/plugin": "^1.1.23"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
   }
 }

package/bun.lock

@@ -1,19 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "opencode-crs-bedrock",
-      "dependencies": {
-        "@opencode-ai/plugin": "*",
-      },
-    },
-  },
-  "packages": {
-    "@opencode-ai/plugin": ["@opencode-ai/plugin@1.1.23", "", { "dependencies": { "@opencode-ai/sdk": "1.1.23", "zod": "4.1.8" } }, "sha512-O/iLSKOUuzD95UWhj9y/tEuycPEBv36de0suHXXqeYLWZLZ16DAUSKR+YG7rvRjJS0sbn4biVMw+k7XXk/oxiQ=="],
-
-    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.1.23", "", {}, "sha512-YjN9ogzkLol92s+/iARXRop9/5oFIezUkvWVay12u1IM6A/WJs50DeKl3oL0x4a68P1a5tI5gD98dLnk2+AlsA=="],
-
-    "zod": ["zod@4.1.8", "", {}, "sha512-5R1P+WwQqmmMIEACyzSvo4JXHY5WiAFHRMg+zBZKgKS+Q1viRa0C1hmUKtHltoIFKtIdki3pRxkmpP74jnNYHQ=="],
-  }
-}

package/dist/index.js

@@ -1,547 +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) || "unknown";
-      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(getAuth) {
-  return async function crsFetch(input, init) {
-    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;
-  };
-}
-var CRSAuthPlugin = async () => {
-  return {
-    auth: {
-      provider: PROVIDER_ID,
-      async loader(getAuth, provider) {
-        let baseURL = provider?.options?.baseURL;
-        if (baseURL && !baseURL.includes("/v1")) {
-          baseURL = baseURL.replace(/\/?$/, "/v1/");
-        }
-        let apiKey = provider?.options?.apiKey;
-        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",
-          prompts: [
-            {
-              type: "text",
-              message: "Enter your CRS API Key (cr_...)",
-              key: "apiKey"
-            }
-          ]
-        }
-      ]
-    }
-  };
-};
-export {
-  CRSAuthPlugin
-};