opencode-cluade-auth 1.0.2 → 1.0.4

package/dist/anthropic-compat.js

@@ -83,7 +83,8 @@ export function extractAnthropicRequest(raw) {
             tools.push({
                 name,
                 description: asText(tool.description).trim() || undefined,
-                inputSchema: isRecord(tool.input_schema) ? tool.input_schema : undefined,
+                inputSchema: (isRecord(tool.inputSchema) ? tool.inputSchema : undefined) ??
+                    (isRecord(tool.input_schema) ? tool.input_schema : undefined),
             });
         }
     }
@@ -136,40 +137,30 @@ export function buildClaudePreparedRequest(params) {
         outputFormat: "text",
     };
 }
-export function parseClaudeResponseEnvelope(text) {
-    const trimmed = text.trim();
-    if (!trimmed) {
-        return null;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(trimmed);
-    }
-    catch {
-        return null;
-    }
-    if (isRecord(parsed) && isRecord(parsed.structured_output)) {
-        parsed = parsed.structured_output;
+function coerceClaudeEnvelope(parsed) {
+    let candidate = parsed;
+    if (isRecord(candidate) && isRecord(candidate.structured_output)) {
+        candidate = candidate.structured_output;
     }
-    if (isRecord(parsed) && typeof parsed.result === "string") {
+    if (isRecord(candidate) && typeof candidate.result === "string") {
         return {
             type: "final",
-            content: parsed.result,
+            content: candidate.result,
         };
     }
-    if (!isRecord(parsed)) {
+    if (!isRecord(candidate)) {
         return null;
     }
-    if (parsed.type === "final") {
+    if (candidate.type === "final") {
         return {
             type: "final",
-            content: asText(parsed.content),
+            content: asText(candidate.content),
         };
     }
-    if (parsed.type !== "tool-calls" || !Array.isArray(parsed.tool_calls)) {
+    if (candidate.type !== "tool-calls" || !Array.isArray(candidate.tool_calls)) {
         return null;
     }
-    const toolCalls = parsed.tool_calls.flatMap((entry) => {
+    const toolCalls = candidate.tool_calls.flatMap((entry) => {
         if (!isRecord(entry)) {
             return [];
         }
@@ -183,6 +174,83 @@ export function parseClaudeResponseEnvelope(text) {
     });
     return toolCalls.length > 0 ? { type: "tool-calls", tool_calls: toolCalls } : null;
 }
+function parseEnvelopeCandidate(candidate) {
+    let parsed;
+    try {
+        parsed = JSON.parse(candidate);
+    }
+    catch {
+        return null;
+    }
+    return coerceClaudeEnvelope(parsed);
+}
+function extractJsonObjectCandidates(text) {
+    const candidates = [];
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escape = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index] ?? "";
+        if (inString) {
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (char === "\\") {
+                escape = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === "{") {
+            if (depth === 0) {
+                start = index;
+            }
+            depth += 1;
+            continue;
+        }
+        if (char === "}") {
+            if (depth > 0) {
+                depth -= 1;
+                if (depth === 0 && start >= 0) {
+                    candidates.push(text.slice(start, index + 1));
+                    start = -1;
+                }
+            }
+        }
+    }
+    return candidates;
+}
+export function parseClaudeResponseEnvelope(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const direct = parseEnvelopeCandidate(trimmed);
+    if (direct) {
+        return direct;
+    }
+    const candidates = extractJsonObjectCandidates(trimmed);
+    for (let index = candidates.length - 1; index >= 0; index -= 1) {
+        const candidate = candidates[index];
+        if (!candidate || candidate === trimmed) {
+            continue;
+        }
+        const envelope = parseEnvelopeCandidate(candidate);
+        if (envelope) {
+            return envelope;
+        }
+    }
+    return null;
+}
 function requiredFieldsFromSchema(schema) {
     if (!schema) {
         return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-cluade-auth",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Claude Code CLI-backed Anthropic auth plugin for OpenCode.",
   "license": "MIT",
   "type": "module",