opencode-crs-bedrock 1.0.5 → 1.0.6

package/index.ts

@@ -1070,10 +1070,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.6",
   "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
-};