@crazy-goat/nexos-provider 1.3.0 → 1.3.1

package/README.md

@@ -105,6 +105,30 @@ opencode → createNexosAI → fetch wrapper → nexos.ai API
                                └─ fix-chatgpt.mjs: passthrough (no fixes needed)
 ```
 
+## Testing
+
+Test with a simple prompt:
+```bash
+opencode run "what is 2+2?" -m "nexos-ai/Gemini 2.5 Pro"
+opencode run "what is 2+2?" -m "nexos-ai/Gemini 2.5 Flash"
+opencode run "what is 2+2?" -m "nexos-ai/Claude Sonnet 4.5"
+opencode run "what is 2+2?" -m "nexos-ai/GPT 5"
+```
+
+Test tool calling:
+```bash
+opencode run "list files in current directory" -m "nexos-ai/Gemini 2.5 Pro"
+opencode run "list files in current directory" -m "nexos-ai/Claude Sonnet 4.5"
+opencode run "list files in current directory" -m "nexos-ai/GPT 5"
+```
+
+Test thinking/reasoning variants:
+```bash
+opencode run "what is 2+2?" -m "nexos-ai/Claude Sonnet 4.5" --variant thinking-high
+opencode run "what is 2+2?" -m "nexos-ai/Gemini 2.5 Pro" --variant thinking-high
+opencode run "what is 2+2?" -m "nexos-ai/GPT 5" --variant high
+```
+
 ## License
 
 MIT

package/fix-chatgpt.mjs

@@ -0,0 +1,11 @@
+export function fixChatGPTRequest(body) {
+  if (body.reasoning_effort === "none") {
+    const { reasoning_effort, ...rest } = body;
+    return rest;
+  }
+  return body;
+}
+
+export function fixChatGPTStream(text) {
+  return text;
+}

package/fix-claude.mjs

@@ -0,0 +1,38 @@
+export function fixClaudeRequest(body) {
+  if (!body.thinking) return { body, hadThinking: false };
+  if (body.thinking.type === "disabled") {
+    const { thinking, ...rest } = body;
+    return { body: rest, hadThinking: true };
+  }
+  const thinking = { ...body.thinking };
+  if (thinking.budgetTokens !== undefined && thinking.budget_tokens === undefined) {
+    thinking.budget_tokens = thinking.budgetTokens;
+    delete thinking.budgetTokens;
+  }
+  const result = { ...body, thinking };
+  if (thinking.budget_tokens && result.max_tokens && result.max_tokens <= thinking.budget_tokens) {
+    result.max_tokens = thinking.budget_tokens + 4096;
+  }
+  return { body: result, hadThinking: true };
+}
+
+export function fixClaudeStream(text) {
+  return text.replace(/data: ({.*})\n/g, (match, jsonStr) => {
+    try {
+      const parsed = JSON.parse(jsonStr);
+      let changed = false;
+      if (parsed.choices) {
+        for (const choice of parsed.choices) {
+          if (choice.finish_reason === "end_turn") {
+            choice.finish_reason = "stop";
+            changed = true;
+          }
+        }
+      }
+      if (changed) {
+        return "data: " + JSON.stringify(parsed) + "\n";
+      }
+    } catch {}
+    return match;
+  });
+}

package/fix-gemini.mjs

@@ -0,0 +1,109 @@
+function resolveRefs(schema, defs) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema)) return schema.map((s) => resolveRefs(s, defs));
+
+  if (schema.$ref || schema.ref) {
+    const refName = (schema.$ref || schema.ref)
+      .replace(/^#\/\$defs\//, "")
+      .replace(/^#\/definitions\//, "");
+    const resolved = defs?.[refName];
+    if (resolved) {
+      const merged = { ...resolveRefs(resolved, defs) };
+      if (schema.description) merged.description = schema.description;
+      if (schema.default !== undefined) merged.default = schema.default;
+      return merged;
+    }
+  }
+
+  const result = {};
+  for (const [k, v] of Object.entries(schema)) {
+    if (k === "$defs" || k === "definitions" || k === "$ref" || k === "ref")
+      continue;
+    result[k] = resolveRefs(v, defs);
+  }
+  return result;
+}
+
+function fixToolSchemas(body) {
+  if (!body.tools?.length) return body;
+  return {
+    ...body,
+    tools: body.tools.map((tool) => {
+      if (tool.type !== "function" || !tool.function?.parameters) return tool;
+      const params = tool.function.parameters;
+      const defs = params.$defs || params.definitions || {};
+      return {
+        ...tool,
+        function: {
+          ...tool.function,
+          parameters: resolveRefs(params, defs),
+        },
+      };
+    }),
+  };
+}
+
+export function isGeminiModel(model) {
+  return typeof model === "string" && model.toLowerCase().includes("gemini");
+}
+
+export function fixGeminiRequest(body) {
+  if (body.tools) {
+    body = fixToolSchemas(body);
+  }
+  return body;
+}
+
+export function fixGeminiThinkingRequest(body) {
+  if (!body.thinking) return { body, hadThinking: false };
+  if (body.thinking.type === "disabled") {
+    const { thinking, ...rest } = body;
+    return { body: rest, hadThinking: true };
+  }
+  const thinking = { ...body.thinking };
+  if (thinking.budgetTokens !== undefined && thinking.budget_tokens === undefined) {
+    thinking.budget_tokens = thinking.budgetTokens;
+    delete thinking.budgetTokens;
+  }
+  const result = { ...body, thinking };
+  if (thinking.budget_tokens && result.max_tokens && result.max_tokens <= thinking.budget_tokens) {
+    result.max_tokens = thinking.budget_tokens + 4096;
+  }
+  return { body: result, hadThinking: true };
+}
+
+export function fixGeminiStream(text) {
+  return text.replace(/data: ({.*})\n/g, (match, jsonStr) => {
+    try {
+      const parsed = JSON.parse(jsonStr);
+      let changed = false;
+      if (parsed.choices) {
+        for (const choice of parsed.choices) {
+          if (choice.finish_reason === "STOP") {
+            choice.finish_reason = "stop";
+            changed = true;
+          }
+          if (choice.finish_reason === "stop" && choice.delta?.tool_calls?.length) {
+            choice.finish_reason = "tool_calls";
+            changed = true;
+          }
+          const blocks = choice.delta?.content_blocks;
+          if (blocks?.length) {
+            for (const block of blocks) {
+              if (block.delta?.thinking) {
+                choice.delta.reasoning_content = block.delta.thinking;
+                changed = true;
+              }
+            }
+            delete choice.delta.content_blocks;
+            changed = true;
+          }
+        }
+      }
+      if (changed) {
+        return "data: " + JSON.stringify(parsed) + "\n";
+      }
+    } catch {}
+    return match;
+  });
+}

package/package.json

@@ -1,19 +1,17 @@
 {
   "name": "@crazy-goat/nexos-provider",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Custom AI SDK provider for nexos.ai Gemini models in opencode",
   "type": "module",
   "main": "index.mjs",
   "exports": {
     ".": "./index.mjs"
   },
-  "bin": "./list-models.mjs",
-  "scripts": {
-    "list-models": "node list-models.mjs"
-  },
   "files": [
     "index.mjs",
-    "list-models.mjs"
+    "fix-gemini.mjs",
+    "fix-claude.mjs",
+    "fix-chatgpt.mjs"
   ],
   "keywords": [
     "opencode",

package/list-models.mjs

@@ -1,47 +0,0 @@
-#!/usr/bin/env node
-
-const baseURL = process.env.NEXOS_BASE_URL || "https://api.nexos.ai/v1";
-const apiKey = process.env.NEXOS_API_KEY;
-
-if (!apiKey) {
-  console.error("Error: NEXOS_API_KEY environment variable is not set");
-  process.exit(1);
-}
-
-const res = await fetch(`${baseURL}/models`, {
-  headers: { Authorization: `Bearer ${apiKey}` },
-});
-
-if (!res.ok) {
-  console.error(`Error: ${res.status} ${res.statusText}`);
-  const body = await res.text();
-  if (body) console.error(body);
-  process.exit(1);
-}
-
-const data = await res.json();
-const models = (data.data || data.models || []).sort((a, b) =>
-  (a.id || a.name || "").localeCompare(b.id || b.name || "")
-);
-
-if (models.length === 0) {
-  console.log("No models found.");
-  process.exit(0);
-}
-
-console.log(`\nAvailable models (${models.length}):\n`);
-
-for (const m of models) {
-  const id = m.id || m.name;
-  console.log(`  - ${id}`);
-}
-
-console.log("\nTo use a model in opencode.json, add it under provider.models:");
-console.log(`
-  "models": {
-    "<model-id>": {
-      "name": "<model-id>",
-      "limit": { "context": 128000, "output": 64000 }
-    }
-  }
-`);