opencode-crs-bedrock 1.0.3 → 1.0.5

package/dist/index.js

@@ -0,0 +1,555 @@
+// 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
+};

package/index.ts

@@ -434,8 +434,37 @@ class SSETransformState {
     controller: TransformStreamDefaultController<string>
   ): void {
     for (const [blockIndex, pending] of this.pendingToolBlocks) {
-      const inferredName =
-        inferToolName(pending.inputBuffer, this.toolSchemas) || "unknown";
+      const inferredName = inferToolName(pending.inputBuffer, this.toolSchemas);
+      
+      // If we couldn't infer a tool name, emit a helpful text block instead of a broken tool_use
+      if (!inferredName) {
+        debugLog(
+          "Could not infer tool name for block",
+          blockIndex,
+          "- converting to text with available tools list"
+        );
+        
+        const availableTools = Array.from(this.toolSchemas.keys()).join(", ");
+        const helpText = `Tool inference failed. The model attempted to call a tool but the tool name could not be determined from the input parameters. Available tools: ${availableTools}. Please specify which tool you want to use.`;
+        
+        // Emit as a text block instead of a tool_use
+        emitSSEEvent(controller, "content_block_start", {
+          type: "content_block_start",
+          index: blockIndex,
+          content_block: {
+            type: "text",
+            text: helpText,
+          },
+        });
+        
+        emitSSEEvent(controller, "content_block_stop", {
+          type: "content_block_stop",
+          index: blockIndex,
+        });
+        
+        continue;
+      }
+      
       debugLog(
         "Flushing pending tool block",
         blockIndex,
@@ -1064,16 +1093,10 @@ export const CRSAuthPlugin: Plugin = async ({ client }: PluginContext) => {
         {
           label: "Enter CRS API Key",
           type: "api",
-          prompts: [
-            {
-              type: "text",
-              message: "Enter your CRS API Key",
-              key: "apiKey",
-            },
-          ],
         },
       ],
     },
   };
 };
 
+export default CRSAuthPlugin;

package/package.json

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