opencode-crs-bedrock 1.0.1 → 1.0.2

package/bun.lock

@@ -5,15 +5,24 @@
     "": {
       "name": "opencode-crs-bedrock",
       "dependencies": {
-        "@opencode-ai/plugin": "*",
+        "@opencode-ai/plugin": "^0.4.45",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
       },
     },
   },
   "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/plugin": ["@opencode-ai/plugin@0.4.45", "", { "dependencies": { "@opencode-ai/sdk": "0.4.19" } }, "sha512-TuD+FNmA6vN+/B82qayCvOyTXRuAtfvU0U95UKSZoNrYgIBhpD/sW/oS65iUv5QwQqzO8BxI4DYWjmLIqCz8uw=="],
+
+    "@opencode-ai/sdk": ["@opencode-ai/sdk@0.4.19", "", {}, "sha512-7V+wDR1+m+TQZAraAh/bOSObiA/uysG1YIXZVe6gl1sQAXDtkG2FYCzs0gTZ/ORdkUKEnr3vyQIk895Mu0CC/w=="],
+
+    "@types/bun": ["@types/bun@1.3.6", "", { "dependencies": { "bun-types": "1.3.6" } }, "sha512-uWCv6FO/8LcpREhenN1d1b6fcspAB+cefwD7uti8C8VffIv0Um08TKMn98FynpTiU38+y2dUO55T11NgDt8VAA=="],
+
+    "@types/node": ["@types/node@22.19.7", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-MciR4AKGHWl7xwxkBa6xUGxQJ4VBOmPTF7sL+iGzuahOFaO0jHCsuEfS80pan1ef4gWId1oWOweIhrDEYLuaOw=="],
 
-    "@opencode-ai/sdk": ["@opencode-ai/sdk@1.1.23", "", {}, "sha512-YjN9ogzkLol92s+/iARXRop9/5oFIezUkvWVay12u1IM6A/WJs50DeKl3oL0x4a68P1a5tI5gD98dLnk2+AlsA=="],
+    "bun-types": ["bun-types@1.3.6", "", { "dependencies": { "@types/node": "*" } }, "sha512-OlFwHcnNV99r//9v5IIOgQ9Uk37gZqrNMCcqEaExdkVq3Avwqok1bJFmvGMCkCE0FqzdY8VMOZpfpR3lwI+CsQ=="],
 
-    "zod": ["zod@4.1.8", "", {}, "sha512-5R1P+WwQqmmMIEACyzSvo4JXHY5WiAFHRMg+zBZKgKS+Q1viRa0C1hmUKtHltoIFKtIdki3pRxkmpP74jnNYHQ=="],
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
   }
 }

package/index.ts

@@ -967,25 +967,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 });
@@ -1016,45 +1009,21 @@ export const CRSAuthPlugin: Plugin = async () => {
     auth: {
       provider: PROVIDER_ID,
 
+      methods: [],
+
       async loader(
-        getAuth: () => Promise<Auth>,
+        _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 {};
-        }
+        const baseURL = provider?.options?.baseURL as string | undefined;
+        const apiKey = provider?.options?.apiKey as string | undefined;
 
         return {
-          apiKey: "",
+          apiKey,
           baseURL,
-          fetch: createCRSFetch(() => Promise.resolve({ key: apiKey! })),
+          fetch: createCRSFetch(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",
-            },
-          ],
-        },
-      ],
     },
   };
 };

package/package.json

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

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
-};