@gopersonal/advisor 1.0.0 → 1.0.2

package/README.md

@@ -9,37 +9,62 @@ An MCP server that gives AI agents access to a separate AI advisor via [OpenCode
 
 ## Add to Claude Code
 
+### Option A: OpenAI endpoint
+
 ```bash
-claude mcp add advisor -- npx -y @gopersonal/advisor
+claude mcp add advisor \
+  -e ADVISOR_PROVIDER=openai \
+  -e ADVISOR_MODEL=gpt-4o \
+  -e ADVISOR_API_KEY=sk-your-key \
+  -- npx -y @gopersonal/advisor
 ```
 
-### With a custom provider
+With a custom OpenAI-compatible endpoint:
 
 ```bash
 claude mcp add advisor \
-  -e ADVISOR_MODEL=anthropic/claude-sonnet-4-5 \
+  -e ADVISOR_PROVIDER=openai \
+  -e ADVISOR_MODEL=gpt-4o \
   -e ADVISOR_API_KEY=sk-your-key \
+  -e ADVISOR_BASE_URL=https://your-openai-proxy.example.com/v1 \
+  -- npx -y @gopersonal/advisor
+```
+
+### Option B: Anthropic endpoint
+
+```bash
+claude mcp add advisor \
+  -e ADVISOR_PROVIDER=anthropic \
+  -e ADVISOR_MODEL=claude-sonnet-4-5 \
+  -e ADVISOR_API_KEY=sk-ant-your-key \
   -- npx -y @gopersonal/advisor
 ```
 
-### With a proxy endpoint
+With a custom Anthropic-compatible endpoint:
 
 ```bash
 claude mcp add advisor \
-  -e ADVISOR_MODEL=anthropic/gpt-5.2-codex \
+  -e ADVISOR_PROVIDER=anthropic \
+  -e ADVISOR_MODEL=claude-sonnet-4-5 \
   -e ADVISOR_API_KEY=none \
-  -e ADVISOR_BASE_URL=https://your-proxy.example.com \
+  -e ADVISOR_BASE_URL=https://your-anthropic-proxy.example.com \
   -- npx -y @gopersonal/advisor
 ```
 
+### No config (uses your local opencode setup)
+
+```bash
+claude mcp add advisor -- npx -y @gopersonal/advisor
+```
+
 ## Environment Variables
 
 | Variable | Description | Example |
 |---|---|---|
-| `ADVISOR_MODEL` | Model in `provider/model` format | `anthropic/claude-sonnet-4-5` |
+| `ADVISOR_PROVIDER` | `openai` or `anthropic` | `openai` |
+| `ADVISOR_MODEL` | Model name | `gpt-4o`, `claude-sonnet-4-5` |
 | `ADVISOR_API_KEY` | API key for the provider | `sk-...` |
-| `ADVISOR_BASE_URL` | Custom base URL (proxies, etc.) | `https://proxy.example.com` |
-| `ADVISOR_NPM` | AI SDK npm package (rare, for non-native providers) | `@ai-sdk/openai-compatible` |
+| `ADVISOR_BASE_URL` | Custom base URL (optional) | `https://proxy.example.com` |
 
 If no env vars are set, the advisor connects to a running opencode instance or starts one using your default opencode config.
 
@@ -55,3 +80,45 @@ If no env vars are set, the advisor connects to a running opencode instance or s
 
 - [OpenCode](https://opencode.ai) installed (`brew install sst/tap/opencode` or `npm i -g opencode`)
 - A configured AI provider (Anthropic, OpenAI, MiniMax, or any of 75+ supported providers)
+
+## Development
+
+```bash
+cd advisor
+npm install
+npm run build
+```
+
+Test locally with Claude Code:
+
+```bash
+claude mcp add advisor -- node /path/to/advisor/build/index.js
+```
+
+## Publishing to npm
+
+1. Login to npm (one-time):
+
+```bash
+npm login
+```
+
+2. Update the version in `package.json`:
+
+```bash
+npm version patch   # 1.0.0 -> 1.0.1 (bug fixes)
+npm version minor   # 1.0.0 -> 1.1.0 (new features)
+npm version major   # 1.0.0 -> 2.0.0 (breaking changes)
+```
+
+3. Publish:
+
+```bash
+npm publish --access public
+```
+
+4. Verify:
+
+```bash
+npm view @gopersonal/advisor
+```

package/build/index.js

@@ -7,32 +7,75 @@ import { createOpencode, createOpencodeClient } from "@opencode-ai/sdk/v2";
 //
 // Pass these via the "env" field in the MCP config JSON.
 //
-// OpenCode natively supports 75+ providers (Anthropic, OpenAI, MiniMax, etc.)
-// so most of the time you just need ADVISOR_MODEL and ADVISOR_API_KEY.
+// Option A: OpenAI-compatible endpoint (most providers, proxies, etc.)
+//   ADVISOR_PROVIDER  = "openai"
+//   ADVISOR_MODEL     = "gpt-4o"
+//   ADVISOR_API_KEY   = "sk-..."
+//   ADVISOR_BASE_URL  = "https://api.openai.com/v1"
 //
-//   ADVISOR_MODEL     - model in "provider/model" format, e.g. "anthropic/claude-sonnet-4-5"
-//                       or "openai/gpt-5.2-codex" or "minimax/minimax-m2.5"
-//   ADVISOR_API_KEY   - API key for the provider (optional if already set in opencode)
-//   ADVISOR_BASE_URL  - custom base URL override (optional, for proxies or custom endpoints)
-//   ADVISOR_NPM       - AI SDK npm package (optional, only for non-native providers)
+// Option B: Anthropic-compatible endpoint
+//   ADVISOR_PROVIDER  = "anthropic"
+//   ADVISOR_MODEL     = "claude-sonnet-4-5"
+//   ADVISOR_API_KEY   = "sk-ant-..."
+//   ADVISOR_BASE_URL  = "https://api.anthropic.com"
 //
+// ADVISOR_BASE_URL is required when using a custom/proxy endpoint.
+// If omitted, the default API URL for the provider is used.
+//
+function resolveProviderAndModel() {
+    const explicitProvider = process.env.ADVISOR_PROVIDER?.toLowerCase();
+    const rawModel = process.env.ADVISOR_MODEL;
+    if (!rawModel)
+        return undefined;
+    if (explicitProvider) {
+        // "openai" provider in opencode uses OpenAI's Responses API which most
+        // compatible endpoints don't support. Use @ai-sdk/openai-compatible instead,
+        // which calls the standard /v1/chat/completions endpoint.
+        if (explicitProvider === "openai") {
+            return {
+                provider: "openai-compat",
+                model: rawModel,
+                fullModel: `openai-compat/${rawModel}`,
+                npm: "@ai-sdk/openai-compatible",
+            };
+        }
+        return {
+            provider: explicitProvider,
+            model: rawModel,
+            fullModel: `${explicitProvider}/${rawModel}`,
+        };
+    }
+    // Legacy "provider/model" format in ADVISOR_MODEL
+    if (rawModel.includes("/")) {
+        const [provider, ...rest] = rawModel.split("/");
+        return {
+            provider,
+            model: rest.join("/"),
+            fullModel: rawModel,
+        };
+    }
+    // Just a model name with no provider — use openai-compatible
+    return {
+        provider: "openai-compat",
+        model: rawModel,
+        fullModel: `openai-compat/${rawModel}`,
+        npm: "@ai-sdk/openai-compatible",
+    };
+}
 function buildOpencodeConfig() {
-    const model = process.env.ADVISOR_MODEL;
+    const resolved = resolveProviderAndModel();
     const apiKey = process.env.ADVISOR_API_KEY;
     const baseURL = process.env.ADVISOR_BASE_URL;
-    const npm = process.env.ADVISOR_NPM;
+    const npm = process.env.ADVISOR_NPM || resolved?.npm;
     const config = {
         // Disable title generation (it uses small_model which may not work with custom providers)
-        small_model: model || undefined,
+        small_model: resolved?.fullModel || undefined,
     };
-    if (model) {
-        config.model = model;
-        console.error(`[advisor] Model: ${model}`);
+    if (resolved) {
+        config.model = resolved.fullModel;
+        console.error(`[advisor] Provider: ${resolved.provider}, Model: ${resolved.model}`);
     }
-    // Extract provider id and model name (e.g. "anthropic" + "gpt-5.2-codex")
-    const providerId = model?.split("/")[0];
-    const modelId = model?.split("/").slice(1).join("/");
-    if (providerId && (apiKey || baseURL || npm)) {
+    if (resolved && (apiKey || baseURL || npm)) {
         const options = {};
         if (apiKey)
             options.apiKey = apiKey;
@@ -42,21 +85,19 @@ function buildOpencodeConfig() {
         if (npm)
             providerConfig.npm = npm;
         // Register the model so opencode knows its capabilities
-        if (modelId) {
-            providerConfig.models = {
-                [modelId]: {
-                    name: modelId,
-                    tool_call: true,
-                    attachment: false,
-                    reasoning: false,
-                    temperature: false, // many proxies don't support temperature
-                    limit: { context: 200000, output: 16384 },
-                },
-            };
-        }
-        config.provider = { [providerId]: providerConfig };
+        providerConfig.models = {
+            [resolved.model]: {
+                name: resolved.model,
+                tool_call: true,
+                attachment: false,
+                reasoning: false,
+                temperature: false, // many proxies don't support temperature
+                limit: { context: 200000, output: 16384 },
+            },
+        };
+        config.provider = { [resolved.provider]: providerConfig };
         if (baseURL)
-            console.error(`[advisor] Custom base URL: ${baseURL}`);
+            console.error(`[advisor] Base URL: ${baseURL}`);
     }
     return config;
 }
@@ -109,13 +150,12 @@ async function getOpencodeClient() {
             `Make sure opencode is installed (https://opencode.ai) and configured with a provider.`);
     }
 }
-// Model override for session prompts (from ADVISOR_MODEL env var)
+// Model override for session prompts
 function getModelOverride() {
-    const model = process.env.ADVISOR_MODEL;
-    if (!model || !model.includes("/"))
+    const resolved = resolveProviderAndModel();
+    if (!resolved)
         return undefined;
-    const [providerID, ...rest] = model.split("/");
-    return { providerID, modelID: rest.join("/") };
+    return { providerID: resolved.provider, modelID: resolved.model };
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gopersonal/advisor",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "type": "module",
   "main": "./build/index.js",
   "bin": {
@@ -15,7 +15,13 @@
     "prepublishOnly": "npm run build",
     "start": "node build/index.js"
   },
-  "keywords": ["mcp", "advisor", "opencode", "ai", "model-context-protocol"],
+  "keywords": [
+    "mcp",
+    "advisor",
+    "opencode",
+    "ai",
+    "model-context-protocol"
+  ],
   "author": "gopersonal",
   "license": "ISC",
   "description": "MCP server that gives AI agents a second opinion via OpenCode SDK",