@crazy-goat/nexos-provider 1.0.0

package/README.md

@@ -0,0 +1,127 @@
+# nexos-provider
+
+Custom [AI SDK](https://sdk.vercel.ai/) provider for using [nexos.ai](https://nexos.ai) Gemini models with [opencode](https://opencode.ai).
+
+## Problem
+
+When accessing Gemini models through the nexos.ai API proxy, two issues prevent them from working with opencode (and likely other AI SDK-based tools):
+
+1. **Missing `data: [DONE]` in SSE streaming** — Gemini responses via nexos don't emit the standard `data: [DONE]` signal at the end of a streaming response. The AI SDK's `EventSourceParserStream` waits indefinitely for more data, causing opencode to hang forever.
+
+2. **`$ref` in tool schemas** — opencode sends JSON Schemas with `$ref` / `$defs` for tool parameters. Gemini (Vertex AI) rejects these with: `Schema.ref was set alongside unsupported fields`.
+
+## Solution
+
+This provider wraps `@ai-sdk/openai-compatible` and intercepts `fetch` to:
+
+- **Append `data: [DONE]\n\n`** to the end of streaming responses from Gemini models (via a `TransformStream` flush handler)
+- **Inline `$ref` references** in tool parameter schemas before sending them to the API
+
+No proxy, no extra processes — everything runs inline inside opencode.
+
+## Setup
+
+### 1. Clone this repo
+
+```bash
+git clone <this-repo> ~/nexos-provider
+cd ~/nexos-provider
+npm install
+```
+
+### 2. Set your API key
+
+```bash
+export NEXOS_API_KEY="your-nexos-api-key"
+```
+
+### 3. Configure opencode
+
+Add the provider to your `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "nexos-gemini": {
+      "npm": "file:///absolute/path/to/nexos-provider/index.mjs",
+      "name": "Nexos Gemini",
+      "env": ["NEXOS_API_KEY"],
+      "options": {
+        "baseURL": "https://api.nexos.ai/v1/",
+        "timeout": 300000
+      },
+      "models": {
+        "Gemini 2.5 Pro": {
+          "name": "Gemini 2.5 Pro",
+          "limit": { "context": 128000, "output": 64000 }
+        },
+        "Gemini 3 Flash Preview": {
+          "name": "Gemini 3 Flash Preview",
+          "limit": { "context": 128000, "output": 64000 }
+        },
+        "Gemini 3 Pro Preview": {
+          "name": "Gemini 3 Pro Preview",
+          "limit": { "context": 128000, "output": 64000 }
+        }
+      }
+    }
+  }
+}
+```
+
+> **Note:** The `npm` path must be an absolute `file://` URL pointing to `index.mjs`.
+
+### 4. Use it
+
+```bash
+opencode run "hello" -m "nexos-gemini/Gemini 2.5 Pro"
+```
+
+Or select the model interactively in opencode with `Ctrl+X M`.
+
+## GPT and Claude models
+
+GPT and Claude models work fine through nexos.ai without this provider — they correctly emit `data: [DONE]` and handle `$ref` schemas. Use the standard `@ai-sdk/openai-compatible` provider for those:
+
+```json
+{
+  "nexos-ai": {
+    "npm": "@ai-sdk/openai-compatible",
+    "name": "Nexos AI",
+    "env": ["NEXOS_API_KEY"],
+    "options": {
+      "baseURL": "https://api.nexos.ai/v1/",
+      "timeout": 300000
+    },
+    "models": {
+      "Claude Opus 4.6": {
+        "name": "Claude Opus 4.6",
+        "limit": { "context": 128000, "output": 64000 }
+      },
+      "GPT 5.2": {
+        "name": "GPT 5.2",
+        "limit": { "context": 128000, "output": 64000 }
+      }
+    }
+  }
+}
+```
+
+## How it works
+
+The provider exports `createNexosAI` which creates a standard AI SDK provider with a custom `fetch` wrapper:
+
+```
+Request flow:
+  opencode → createNexosAI → fetch wrapper → nexos.ai API
+                                 │
+                                 ├─ Resolves $ref in tool schemas (for Gemini)
+                                 └─ Appends data: [DONE] to SSE stream (for Gemini)
+```
+
+Only Gemini model requests are modified — all other models pass through unchanged.
+
+## License
+
+MIT

package/index.mjs

@@ -0,0 +1,134 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+
+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),
+        },
+      };
+    }),
+  };
+}
+
+function fixFinishReason(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.delta?.tool_calls?.length) {
+            choice.finish_reason = "tool_calls";
+            changed = true;
+          }
+        }
+      }
+      if (changed) {
+        return "data: " + JSON.stringify(parsed) + "\n";
+      }
+    } catch {}
+    return match;
+  });
+}
+
+function appendDoneToStream() {
+  const encoder = new TextEncoder();
+  let sawDone = false;
+
+  return new TransformStream({
+    transform(chunk, controller) {
+      let text =
+        typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+      if (text.includes("[DONE]")) sawDone = true;
+      text = fixFinishReason(text);
+      controller.enqueue(encoder.encode(text));
+    },
+    flush(controller) {
+      if (!sawDone) {
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+      }
+    },
+  });
+}
+
+function isGeminiModel(model) {
+  return typeof model === "string" && model.toLowerCase().includes("gemini");
+}
+
+function createNexosFetch(baseFetch) {
+  const realFetch = baseFetch || globalThis.fetch;
+
+  return async function nexosFetch(url, init) {
+    let requestBody;
+    try {
+      requestBody = init?.body ? JSON.parse(init.body) : {};
+    } catch {
+      requestBody = {};
+    }
+
+    const gemini = isGeminiModel(requestBody.model);
+
+    if (gemini) {
+      if (requestBody.tools) {
+        requestBody = fixToolSchemas(requestBody);
+      }
+      init = { ...init, body: JSON.stringify(requestBody) };
+    }
+
+    const response = await realFetch(url, init);
+
+    if (gemini && requestBody.stream) {
+      const fixedBody = response.body.pipeThrough(appendDoneToStream());
+      return new Response(fixedBody, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+    }
+
+    return response;
+  };
+}
+
+export function createNexosAI(options = {}) {
+  return createOpenAICompatible({
+    ...options,
+    name: options.name || "nexos-ai",
+    fetch: createNexosFetch(options.fetch),
+  });
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@crazy-goat/nexos-provider",
+  "version": "1.0.0",
+  "description": "Custom AI SDK provider for nexos.ai Gemini models in opencode",
+  "type": "module",
+  "main": "index.mjs",
+  "exports": {
+    ".": "./index.mjs"
+  },
+  "files": [
+    "index.mjs"
+  ],
+  "keywords": [
+    "opencode",
+    "ai-sdk",
+    "nexos",
+    "gemini",
+    "provider"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/crazy-goat/nexos-provider.git"
+  },
+  "homepage": "https://github.com/crazy-goat/nexos-provider",
+  "bugs": {
+    "url": "https://github.com/crazy-goat/nexos-provider/issues"
+  },
+  "dependencies": {
+    "@ai-sdk/openai-compatible": "1.0.32"
+  }
+}