@atlascloudai/opencode 0.0.1

package/README.md

@@ -0,0 +1,191 @@
+# Atlas Cloud Plugin for OpenCode
+
+An [OpenCode](https://opencode.ai) plugin that integrates [Atlas Cloud's](https://atlascloud.ai) OpenAI-compatible API, giving you access to 100+ AI models including GPT-4o, Claude, Gemini, DeepSeek, and more.
+
+## Quick Start
+
+### 1. Install and register the plugin
+
+```bash
+npx @atlascloudai/opencode
+```
+
+This downloads the plugin and registers it with OpenCode.
+
+**Alternative: Global install**
+```bash
+npm install -g @atlascloudai/opencode
+atlascloudai-opencode
+```
+
+### 3. Start OpenCode and connect
+
+```bash
+opencode
+```
+
+Then connect with your Atlas Cloud API key:
+
+```
+/connect atlascloud YOUR_API_KEY
+```
+
+### 4. Restart OpenCode to load models
+
+Exit and restart OpenCode. Your Atlas Cloud models will now be available via `/models`.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/connect atlascloud <api_key>` | Connect with your API key |
+| `/atlascloud status` | Check connection status |
+| `/atlascloud disconnect` | Remove your API key |
+
+## Available Models
+
+The plugin dynamically fetches all available models from Atlas Cloud. Popular models include:
+
+**OpenAI**: GPT-4o, GPT-4o Mini, GPT-4.1, GPT-5, O1, O3, O3 Mini
+
+**Anthropic**: Claude Sonnet 4.5, Claude Opus 4.5, Claude Haiku 4.5
+
+**Google**: Gemini 2.5 Flash, Gemini 2.5 Pro, Gemini 3 Flash Preview
+
+**DeepSeek**: DeepSeek V3.1, DeepSeek V3.2, DeepSeek R1
+
+**xAI**: Grok 4
+
+And many more...
+
+## Configuration
+
+### API Key Sources (in priority order)
+
+1. **OpenCode auth.json** - `~/.local/share/opencode/auth.json`
+2. **Plugin config** - `~/.atlascloud/config.json`
+3. **Environment variable** - `ATLASCLOUD_API_KEY`
+
+### Manual Configuration
+
+If you prefer not to use `/connect`, you can manually create the config:
+
+**Option 1: Environment variable**
+```bash
+export ATLASCLOUD_API_KEY=your-api-key
+```
+
+**Option 2: Config file** (`~/.atlascloud/config.json`)
+```json
+{
+  "version": "1.0.0",
+  "apiKey": "your-api-key"
+}
+```
+
+## Development
+
+### Prerequisites
+
+- Node.js >= 18.0.0
+- npm or bun
+- [OpenCode](https://opencode.ai) installed
+
+### Local Development
+
+```bash
+# Clone the repository
+git clone https://github.com/atlascloud/opencode-plugin.git
+cd opencode-plugin
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Register plugin locally
+node bin/setup.cjs
+
+# Start OpenCode
+opencode
+```
+
+### Watch Mode
+
+```bash
+npm run dev
+```
+
+### Testing in Docker
+
+For a clean, isolated test environment:
+
+```bash
+# Build Docker image
+make build
+
+# Run container
+make run
+
+# Inside container:
+node bin/setup.cjs    # Register plugin
+opencode              # Start OpenCode
+```
+
+## Troubleshooting
+
+### Models not showing up
+
+1. Ensure you've run `/connect atlascloud <api_key>` with a valid key
+2. **Restart OpenCode** after connecting (required to load models)
+3. Check status with `/atlascloud status`
+
+### Invalid API key error
+
+1. Verify your key at [Atlas Cloud dashboard](https://atlascloud.ai)
+2. Reconnect with `/connect atlascloud <new_key>`
+
+### Plugin not loading
+
+1. Run `npx @atlascloudai/opencode` to re-register
+2. Check `~/.config/opencode/opencode.json` has the plugin listed
+
+### Debug mode
+
+Enable debug logging:
+```bash
+ATLASCLOUD_DEBUG=1 opencode
+```
+
+## Architecture
+
+```
+opencode-atlascloud-plugin/
+├── bin/
+│   └── setup.cjs          # CLI setup script
+├── src/
+│   ├── index.ts           # Plugin entry point
+│   └── server/
+│       ├── config.ts      # Configuration management
+│       └── models.ts      # Model fetching & formatting
+├── dist/                  # Compiled output
+├── package.json
+└── tsconfig.json
+```
+
+## API Reference
+
+**Base URL**: `https://api.atlascloud.ai/v1`
+
+The plugin uses Atlas Cloud's OpenAI-compatible API via `@ai-sdk/openai-compatible`.
+
+## License
+
+MIT
+
+## Links
+
+- [Atlas Cloud](https://atlascloud.ai)
+- [OpenCode](https://opencode.ai)
+- [Report Issues](https://github.com/atlascloud/opencode-plugin/issues)

package/bin/setup.cjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const PLUGIN_NAME = "opencode-atlascloud-plugin";
+const CONFIG_DIR = path.join(os.homedir(), ".config", "opencode");
+const CONFIG_FILE = path.join(CONFIG_DIR, "opencode.json");
+
+function log(message) {
+  console.log(`[${PLUGIN_NAME}] ${message}`);
+}
+
+function error(message) {
+  console.error(`[${PLUGIN_NAME}] ERROR: ${message}`);
+}
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    log(`Created config directory: ${CONFIG_DIR}`);
+  }
+}
+
+function loadConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+      return JSON.parse(content);
+    } catch (e) {
+      error(`Failed to parse existing config: ${e.message}`);
+      return {};
+    }
+  }
+  return {};
+}
+
+function saveConfig(config) {
+  // Backup existing config
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.writeFileSync(CONFIG_FILE + ".bak", fs.readFileSync(CONFIG_FILE));
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function registerPlugin() {
+  ensureConfigDir();
+
+  const config = loadConfig();
+
+  // Get the plugin path (parent directory of bin/)
+  const pluginPath = path.resolve(__dirname, "..");
+
+  // Verify dist/index.js exists
+  const indexPath = path.join(pluginPath, "dist", "index.js");
+  if (!fs.existsSync(indexPath)) {
+    throw new Error(`Plugin not built. Run 'npm run build' first. Expected: ${indexPath}`);
+  }
+
+  log(`Plugin path: ${pluginPath}`);
+
+  // Initialize plugin array if it doesn't exist
+  if (!config.plugin) {
+    config.plugin = [];
+  }
+
+  // Check if plugin is already registered (by name or path)
+  const alreadyExists = config.plugin.some(
+    (p) => p === PLUGIN_NAME || p === pluginPath || (typeof p === "string" && p.includes(PLUGIN_NAME))
+  );
+
+  if (alreadyExists) {
+    log("Plugin already configured.");
+  } else {
+    // Push the local path, not the package name
+    config.plugin.push(pluginPath);
+    saveConfig(config);
+    log("Plugin added to configuration.");
+    log(`Configuration saved: ${CONFIG_FILE}`);
+  }
+
+  return true;
+}
+
+function printInstructions() {
+  console.log("\n" + "=".repeat(60));
+  console.log("  Atlas Cloud Plugin for OpenCode - Setup Complete");
+  console.log("=".repeat(60));
+  console.log("\nNext steps:");
+  console.log("\n1. Start OpenCode:");
+  console.log("   $ opencode");
+  console.log("\n2. Connect your Atlas Cloud account by asking:");
+  console.log('   "Connect to Atlas Cloud with API key YOUR_API_KEY"');
+  console.log("\n3. Restart OpenCode to load the models");
+  console.log("\n4. Select an Atlas Cloud model:");
+  console.log("   /models");
+  console.log("\n" + "=".repeat(60));
+  console.log("\nAlternative: Set the ATLASCLOUD_API_KEY environment variable:");
+  console.log("   export ATLASCLOUD_API_KEY=your-api-key");
+  console.log("\nOr create ~/.atlascloud/config.json:");
+  console.log('   { "version": "1.0.0", "apiKey": "your-api-key" }');
+  console.log("\n" + "=".repeat(60));
+  console.log("\nAvailable tools provided by this plugin:");
+  console.log("  - atlascloud_connect: Set your API key");
+  console.log("  - atlascloud_status: Check connection status");
+  console.log("  - atlascloud_disconnect: Remove your API key");
+  console.log("\n" + "=".repeat(60) + "\n");
+}
+
+function main() {
+  log("Setting up Atlas Cloud plugin for OpenCode...\n");
+
+  try {
+    registerPlugin();
+    printInstructions();
+  } catch (e) {
+    error(`Setup failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const AtlasCloudPlugin: Plugin;
+export default AtlasCloudPlugin;

package/dist/index.js

@@ -0,0 +1,207 @@
+import { loadConfig, saveApiKey, getApiKey, clearApiKey } from "./server/config.js";
+import { fetchModels, modelsToOpenCodeFormat, validateApiKey, ATLAS_CLOUD_API_BASE, } from "./server/models.js";
+const PROVIDER_ID = "atlascloud";
+const PROVIDER_NAME = "Atlas Cloud";
+// Custom fetch that strips Anthropic-specific parameters that Atlas Cloud doesn't support
+function createAtlasCloudFetch() {
+    return async (url, init) => {
+        if (init?.body && typeof init.body === "string") {
+            try {
+                const body = JSON.parse(init.body);
+                // Strip cache_control from messages (Anthropic-specific)
+                if (body.messages && Array.isArray(body.messages)) {
+                    body.messages = body.messages.map((msg) => {
+                        const { cache_control, ...rest } = msg;
+                        // Also strip cache_control from content if it's an array
+                        if (Array.isArray(rest.content)) {
+                            rest.content = rest.content.map((c) => {
+                                const { cache_control: cc, ...contentRest } = c;
+                                return contentRest;
+                            });
+                        }
+                        return rest;
+                    });
+                }
+                // Strip other Anthropic-specific parameters
+                delete body.anthropic_version;
+                delete body.metadata;
+                init = {
+                    ...init,
+                    body: JSON.stringify(body),
+                };
+            }
+            catch {
+                // Not JSON or parse error, pass through as-is
+            }
+        }
+        return fetch(url, init);
+    };
+}
+async function handleConnectCommand(args) {
+    const key = args[0];
+    if (!key) {
+        return {
+            handled: true,
+            error: `Usage: /connect atlascloud <your_api_key>`,
+        };
+    }
+    try {
+        const isValid = await validateApiKey(key);
+        if (!isValid) {
+            return {
+                handled: true,
+                error: `❌ **Invalid API Key**\n\nThe API key could not be validated. Please check your key and try again.`,
+            };
+        }
+        saveApiKey(key);
+        const models = await fetchModels(key);
+        const masked = key.substring(0, 8) + "..." + key.substring(key.length - 4);
+        return {
+            handled: true,
+            response: `✅ **Atlas Cloud Connected!**\n\n- Key: \`${masked}\`\n- Models Available: ${models.length}\n\n**Restart OpenCode** to load the models.`,
+        };
+    }
+    catch (e) {
+        clearApiKey();
+        return {
+            handled: true,
+            error: `❌ **Connection Failed**: ${e.message || e}`,
+        };
+    }
+}
+async function handleStatusCommand() {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        return {
+            handled: true,
+            response: `ℹ️ **Atlas Cloud Status**\n\nNot connected. Use \`/connect atlascloud <api_key>\` to connect.`,
+        };
+    }
+    try {
+        const isValid = await validateApiKey(apiKey);
+        if (isValid) {
+            const models = await fetchModels(apiKey);
+            const masked = apiKey.substring(0, 8) + "...";
+            return {
+                handled: true,
+                response: `✅ **Atlas Cloud Status**\n\n- Connected: Yes\n- Key: \`${masked}\`\n- Models: ${models.length}`,
+            };
+        }
+        else {
+            return {
+                handled: true,
+                error: `⚠️ **Atlas Cloud Status**\n\nAPI key is configured but invalid. Use \`/connect atlascloud <api_key>\` to update.`,
+            };
+        }
+    }
+    catch (e) {
+        return {
+            handled: true,
+            error: `❌ **Status Check Failed**: ${e.message || e}`,
+        };
+    }
+}
+async function handleDisconnectCommand() {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        return {
+            handled: true,
+            response: `ℹ️ Atlas Cloud is not connected.`,
+        };
+    }
+    clearApiKey();
+    return {
+        handled: true,
+        response: `✅ **Disconnected from Atlas Cloud**\n\nAPI key removed. Restart OpenCode for changes to take effect.`,
+    };
+}
+async function handleCommand(command) {
+    const parts = command.trim().split(/\s+/);
+    const cmd = parts[0]?.toLowerCase();
+    const subCmd = parts[1]?.toLowerCase();
+    const args = parts.slice(2);
+    // Handle /connect atlascloud <key>
+    if (cmd === "connect" && subCmd === "atlascloud") {
+        return handleConnectCommand(args);
+    }
+    // Handle /atlascloud <subcommand>
+    if (cmd === "atlascloud") {
+        switch (subCmd) {
+            case "connect":
+                return handleConnectCommand(args);
+            case "status":
+                return handleStatusCommand();
+            case "disconnect":
+                return handleDisconnectCommand();
+            default:
+                return {
+                    handled: true,
+                    response: `**Atlas Cloud Commands**\n\n- \`/atlascloud connect <api_key>\` - Connect with API key\n- \`/atlascloud status\` - Check connection status\n- \`/atlascloud disconnect\` - Remove API key\n\nOr use: \`/connect atlascloud <api_key>\``,
+                };
+        }
+    }
+    return { handled: false };
+}
+// Debug logging helper
+const DEBUG = process.env.ATLASCLOUD_DEBUG === "1" || process.env.DEBUG?.includes("atlascloud");
+function log(...args) {
+    if (DEBUG) {
+        console.error("[atlascloud-plugin]", ...args);
+    }
+}
+// Helper to safely display API key
+function maskKey(key) {
+    if (typeof key === "string" && key.length > 0) {
+        return key.slice(0, 12) + "...";
+    }
+    return "NONE";
+}
+export const AtlasCloudPlugin = async (ctx) => {
+    log("Plugin initializing...");
+    // Load configuration and fetch models on plugin initialization
+    const loadedConfig = loadConfig();
+    const apiKey = loadedConfig.apiKey;
+    log("API key loaded:", maskKey(apiKey));
+    // Fetch models (will use fallback if no API key)
+    const models = await fetchModels(apiKey);
+    const modelsObject = modelsToOpenCodeFormat(models);
+    log("Models loaded:", Object.keys(modelsObject).length);
+    log("Sample models:", Object.keys(modelsObject).slice(0, 5).join(", "));
+    return {
+        // Configuration hook to register the provider
+        config: async (config) => {
+            const currentApiKey = getApiKey();
+            log("Config hook called, apiKey:", maskKey(currentApiKey));
+            // Access the config to add the provider
+            const cfg = config;
+            cfg.provider = cfg.provider || {};
+            // Don't specify apiKey here - OpenCode will resolve it from auth.json
+            // The auth.json format is: { "atlascloud": { "type": "api", "key": "..." } }
+            log("Provider config: OpenCode will resolve API key from auth.json");
+            const providerConfig = {
+                id: PROVIDER_ID,
+                name: PROVIDER_NAME,
+                npm: "@ai-sdk/openai-compatible",
+                options: {
+                    baseURL: ATLAS_CLOUD_API_BASE,
+                },
+                models: modelsObject,
+            };
+            cfg.provider[PROVIDER_ID] = providerConfig;
+            log("Provider registered:", JSON.stringify({ ...providerConfig, models: `[${Object.keys(modelsObject).length} models]` }, null, 2));
+        },
+        // Command hook for /connect atlascloud and /atlascloud commands
+        "tui.command.execute": async (input, output) => {
+            const result = await handleCommand(input.command);
+            if (result.handled) {
+                output.handled = true;
+                if (result.response)
+                    output.response = result.response;
+                if (result.error)
+                    output.error = result.error;
+            }
+        },
+    };
+};
+export default AtlasCloudPlugin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Plugin } from \"@opencode-ai/plugin\";\nimport { loadConfig, saveApiKey, getApiKey, clearApiKey } from \"./server/config.js\";\nimport {\n  fetchModels,\n  modelsToOpenCodeFormat,\n  validateApiKey,\n  ATLAS_CLOUD_API_BASE,\n} from \"./server/models.js\";\n\nconst PROVIDER_ID = \"atlascloud\";\nconst PROVIDER_NAME = \"Atlas Cloud\";\n\n// Custom fetch that strips Anthropic-specific parameters that Atlas Cloud doesn't support\nfunction createAtlasCloudFetch() {\n  return async (url: string | URL | Request, init?: RequestInit): Promise<Response> => {\n    if (init?.body && typeof init.body === \"string\") {\n      try {\n        const body = JSON.parse(init.body);\n\n        // Strip cache_control from messages (Anthropic-specific)\n        if (body.messages && Array.isArray(body.messages)) {\n          body.messages = body.messages.map((msg: any) => {\n            const { cache_control, ...rest } = msg;\n            // Also strip cache_control from content if it's an array\n            if (Array.isArray(rest.content)) {\n              rest.content = rest.content.map((c: any) => {\n                const { cache_control: cc, ...contentRest } = c;\n                return contentRest;\n              });\n            }\n            return rest;\n          });\n        }\n\n        // Strip other Anthropic-specific parameters\n        delete body.anthropic_version;\n        delete body.metadata;\n\n        init = {\n          ...init,\n          body: JSON.stringify(body),\n        };\n      } catch {\n        // Not JSON or parse error, pass through as-is\n      }\n    }\n\n    return fetch(url, init);\n  };\n}\n\ninterface CommandResult {\n  handled: boolean;\n  response?: string;\n  error?: string;\n}\n\nasync function handleConnectCommand(args: string[]): Promise<CommandResult> {\n  const key = args[0];\n\n  if (!key) {\n    return {\n      handled: true,\n      error: `Usage: /connect atlascloud <your_api_key>`,\n    };\n  }\n\n  try {\n    const isValid = await validateApiKey(key);\n\n    if (!isValid) {\n      return {\n        handled: true,\n        error: `❌ **Invalid API Key**\\n\\nThe API key could not be validated. Please check your key and try again.`,\n      };\n    }\n\n    saveApiKey(key);\n    const models = await fetchModels(key);\n    const masked = key.substring(0, 8) + \"...\" + key.substring(key.length - 4);\n\n    return {\n      handled: true,\n      response: `✅ **Atlas Cloud Connected!**\\n\\n- Key: \\`${masked}\\`\\n- Models Available: ${models.length}\\n\\n**Restart OpenCode** to load the models.`,\n    };\n  } catch (e: any) {\n    clearApiKey();\n    return {\n      handled: true,\n      error: `❌ **Connection Failed**: ${e.message || e}`,\n    };\n  }\n}\n\nasync function handleStatusCommand(): Promise<CommandResult> {\n  const apiKey = getApiKey();\n\n  if (!apiKey) {\n    return {\n      handled: true,\n      response: `ℹ️ **Atlas Cloud Status**\\n\\nNot connected. Use \\`/connect atlascloud <api_key>\\` to connect.`,\n    };\n  }\n\n  try {\n    const isValid = await validateApiKey(apiKey);\n    if (isValid) {\n      const models = await fetchModels(apiKey);\n      const masked = apiKey.substring(0, 8) + \"...\";\n      return {\n        handled: true,\n        response: `✅ **Atlas Cloud Status**\\n\\n- Connected: Yes\\n- Key: \\`${masked}\\`\\n- Models: ${models.length}`,\n      };\n    } else {\n      return {\n        handled: true,\n        error: `⚠️ **Atlas Cloud Status**\\n\\nAPI key is configured but invalid. Use \\`/connect atlascloud <api_key>\\` to update.`,\n      };\n    }\n  } catch (e: any) {\n    return {\n      handled: true,\n      error: `❌ **Status Check Failed**: ${e.message || e}`,\n    };\n  }\n}\n\nasync function handleDisconnectCommand(): Promise<CommandResult> {\n  const apiKey = getApiKey();\n\n  if (!apiKey) {\n    return {\n      handled: true,\n      response: `ℹ️ Atlas Cloud is not connected.`,\n    };\n  }\n\n  clearApiKey();\n  return {\n    handled: true,\n    response: `✅ **Disconnected from Atlas Cloud**\\n\\nAPI key removed. Restart OpenCode for changes to take effect.`,\n  };\n}\n\nasync function handleCommand(command: string): Promise<CommandResult> {\n  const parts = command.trim().split(/\\s+/);\n  const cmd = parts[0]?.toLowerCase();\n  const subCmd = parts[1]?.toLowerCase();\n  const args = parts.slice(2);\n\n  // Handle /connect atlascloud <key>\n  if (cmd === \"connect\" && subCmd === \"atlascloud\") {\n    return handleConnectCommand(args);\n  }\n\n  // Handle /atlascloud <subcommand>\n  if (cmd === \"atlascloud\") {\n    switch (subCmd) {\n      case \"connect\":\n        return handleConnectCommand(args);\n      case \"status\":\n        return handleStatusCommand();\n      case \"disconnect\":\n        return handleDisconnectCommand();\n      default:\n        return {\n          handled: true,\n          response: `**Atlas Cloud Commands**\\n\\n- \\`/atlascloud connect <api_key>\\` - Connect with API key\\n- \\`/atlascloud status\\` - Check connection status\\n- \\`/atlascloud disconnect\\` - Remove API key\\n\\nOr use: \\`/connect atlascloud <api_key>\\``,\n        };\n    }\n  }\n\n  return { handled: false };\n}\n\n// Debug logging helper\nconst DEBUG = process.env.ATLASCLOUD_DEBUG === \"1\" || process.env.DEBUG?.includes(\"atlascloud\");\nfunction log(...args: any[]) {\n  if (DEBUG) {\n    console.error(\"[atlascloud-plugin]\", ...args);\n  }\n}\n\n// Helper to safely display API key\nfunction maskKey(key: unknown): string {\n  if (typeof key === \"string\" && key.length > 0) {\n    return key.slice(0, 12) + \"...\";\n  }\n  return \"NONE\";\n}\n\nexport const AtlasCloudPlugin: Plugin = async (ctx) => {\n  log(\"Plugin initializing...\");\n\n  // Load configuration and fetch models on plugin initialization\n  const loadedConfig = loadConfig();\n  const apiKey = loadedConfig.apiKey;\n  log(\"API key loaded:\", maskKey(apiKey));\n\n  // Fetch models (will use fallback if no API key)\n  const models = await fetchModels(apiKey);\n  const modelsObject = modelsToOpenCodeFormat(models);\n  log(\"Models loaded:\", Object.keys(modelsObject).length);\n  log(\"Sample models:\", Object.keys(modelsObject).slice(0, 5).join(\", \"));\n\n  return {\n    // Configuration hook to register the provider\n    config: async (config) => {\n      const currentApiKey = getApiKey();\n      log(\"Config hook called, apiKey:\", maskKey(currentApiKey));\n\n      // Access the config to add the provider\n      const cfg = config as Record<string, unknown>;\n      cfg.provider = cfg.provider || {};\n\n      // Don't specify apiKey here - OpenCode will resolve it from auth.json\n      // The auth.json format is: { \"atlascloud\": { \"type\": \"api\", \"key\": \"...\" } }\n      log(\"Provider config: OpenCode will resolve API key from auth.json\");\n\n      const providerConfig = {\n        id: PROVIDER_ID,\n        name: PROVIDER_NAME,\n        npm: \"@ai-sdk/openai-compatible\",\n        options: {\n          baseURL: ATLAS_CLOUD_API_BASE,\n        },\n        models: modelsObject,\n      };\n\n      (cfg.provider as Record<string, unknown>)[PROVIDER_ID] = providerConfig;\n      log(\"Provider registered:\", JSON.stringify({ ...providerConfig, models: `[${Object.keys(modelsObject).length} models]` }, null, 2));\n    },\n\n    // Command hook for /connect atlascloud and /atlascloud commands\n    \"tui.command.execute\": async (input: any, output: any) => {\n      const result = await handleCommand(input.command);\n      if (result.handled) {\n        output.handled = true;\n        if (result.response) output.response = result.response;\n        if (result.error) output.error = result.error;\n      }\n    },\n  };\n};\n\nexport default AtlasCloudPlugin;\n"]}

package/dist/server/config.d.ts

@@ -0,0 +1,9 @@
+export interface AtlasCloudConfig {
+    version: string;
+    apiKey?: string;
+}
+export declare function loadConfig(): AtlasCloudConfig;
+export declare function saveConfig(config: AtlasCloudConfig): void;
+export declare function saveApiKey(apiKey: string): void;
+export declare function getApiKey(): string | undefined;
+export declare function clearApiKey(): void;

package/dist/server/config.js

@@ -0,0 +1,133 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const CONFIG_DIR = path.join(os.homedir(), ".atlascloud");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const OPENCODE_AUTH_DIR = path.join(os.homedir(), ".local", "share", "opencode");
+const OPENCODE_AUTH_FILE = path.join(OPENCODE_AUTH_DIR, "auth.json");
+const DEFAULT_CONFIG = {
+    version: "1.0.0",
+};
+function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+function ensureOpenCodeAuthDir() {
+    if (!fs.existsSync(OPENCODE_AUTH_DIR)) {
+        fs.mkdirSync(OPENCODE_AUTH_DIR, { recursive: true });
+    }
+}
+export function loadConfig() {
+    // First, try to load from our own config file
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+            const config = JSON.parse(content);
+            if (config.apiKey) {
+                return config;
+            }
+        }
+        catch (error) {
+            // Config file exists but is invalid, continue to check other sources
+        }
+    }
+    // Check OpenCode's auth.json for the "atlascloud" key
+    if (fs.existsSync(OPENCODE_AUTH_FILE)) {
+        try {
+            const content = fs.readFileSync(OPENCODE_AUTH_FILE, "utf-8");
+            const authData = JSON.parse(content);
+            const atlasAuth = authData.atlascloud;
+            // Handle both new format { type: "api", key: "..." } and legacy string format
+            if (atlasAuth) {
+                const key = typeof atlasAuth === "object" && atlasAuth.type === "api"
+                    ? atlasAuth.key
+                    : typeof atlasAuth === "string"
+                        ? atlasAuth
+                        : undefined;
+                if (key) {
+                    return {
+                        ...DEFAULT_CONFIG,
+                        apiKey: key,
+                    };
+                }
+            }
+        }
+        catch (error) {
+            // Auth file exists but is invalid or doesn't have atlascloud key
+        }
+    }
+    // Check environment variable
+    const envApiKey = process.env.ATLASCLOUD_API_KEY;
+    if (envApiKey) {
+        return {
+            ...DEFAULT_CONFIG,
+            apiKey: envApiKey,
+        };
+    }
+    return DEFAULT_CONFIG;
+}
+export function saveConfig(config) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function loadOpenCodeAuth() {
+    if (fs.existsSync(OPENCODE_AUTH_FILE)) {
+        try {
+            const content = fs.readFileSync(OPENCODE_AUTH_FILE, "utf-8");
+            return JSON.parse(content);
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+function saveOpenCodeAuth(auth) {
+    ensureOpenCodeAuthDir();
+    fs.writeFileSync(OPENCODE_AUTH_FILE, JSON.stringify(auth, null, 2));
+}
+export function saveApiKey(apiKey) {
+    // Save to our own config
+    const config = loadConfig();
+    config.apiKey = apiKey;
+    saveConfig(config);
+    // Save to OpenCode's auth.json in the correct format
+    const existingAuth = loadOpenCodeAuth();
+    const auth = {};
+    // Preserve existing entries (convert if needed)
+    for (const [key, value] of Object.entries(existingAuth)) {
+        if (typeof value === "object" && value !== null && value.type === "api") {
+            auth[key] = value;
+        }
+    }
+    // Add/update atlascloud entry
+    auth.atlascloud = {
+        type: "api",
+        key: apiKey,
+    };
+    saveOpenCodeAuth(auth);
+}
+export function getApiKey() {
+    return loadConfig().apiKey;
+}
+export function clearApiKey() {
+    // Clear from our config
+    const config = loadConfig();
+    delete config.apiKey;
+    saveConfig(config);
+    // Also clear from OpenCode's auth.json
+    if (fs.existsSync(OPENCODE_AUTH_FILE)) {
+        try {
+            const content = fs.readFileSync(OPENCODE_AUTH_FILE, "utf-8");
+            const authData = JSON.parse(content);
+            delete authData.atlascloud;
+            ensureOpenCodeAuthDir();
+            fs.writeFileSync(OPENCODE_AUTH_FILE, JSON.stringify(authData, null, 2));
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/server/config.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport * as os from \"node:os\";\n\nexport interface AtlasCloudConfig {\n  version: string;\n  apiKey?: string;\n}\n\nconst CONFIG_DIR = path.join(os.homedir(), \".atlascloud\");\nconst CONFIG_FILE = path.join(CONFIG_DIR, \"config.json\");\nconst OPENCODE_AUTH_DIR = path.join(os.homedir(), \".local\", \"share\", \"opencode\");\nconst OPENCODE_AUTH_FILE = path.join(OPENCODE_AUTH_DIR, \"auth.json\");\n\nconst DEFAULT_CONFIG: AtlasCloudConfig = {\n  version: \"1.0.0\",\n};\n\nfunction ensureConfigDir(): void {\n  if (!fs.existsSync(CONFIG_DIR)) {\n    fs.mkdirSync(CONFIG_DIR, { recursive: true });\n  }\n}\n\nfunction ensureOpenCodeAuthDir(): void {\n  if (!fs.existsSync(OPENCODE_AUTH_DIR)) {\n    fs.mkdirSync(OPENCODE_AUTH_DIR, { recursive: true });\n  }\n}\n\nexport function loadConfig(): AtlasCloudConfig {\n  // First, try to load from our own config file\n  if (fs.existsSync(CONFIG_FILE)) {\n    try {\n      const content = fs.readFileSync(CONFIG_FILE, \"utf-8\");\n      const config = JSON.parse(content) as AtlasCloudConfig;\n      if (config.apiKey) {\n        return config;\n      }\n    } catch (error) {\n      // Config file exists but is invalid, continue to check other sources\n    }\n  }\n\n  // Check OpenCode's auth.json for the \"atlascloud\" key\n  if (fs.existsSync(OPENCODE_AUTH_FILE)) {\n    try {\n      const content = fs.readFileSync(OPENCODE_AUTH_FILE, \"utf-8\");\n      const authData = JSON.parse(content);\n      const atlasAuth = authData.atlascloud;\n      // Handle both new format { type: \"api\", key: \"...\" } and legacy string format\n      if (atlasAuth) {\n        const key = typeof atlasAuth === \"object\" && atlasAuth.type === \"api\"\n          ? atlasAuth.key\n          : typeof atlasAuth === \"string\"\n            ? atlasAuth\n            : undefined;\n        if (key) {\n          return {\n            ...DEFAULT_CONFIG,\n            apiKey: key,\n          };\n        }\n      }\n    } catch (error) {\n      // Auth file exists but is invalid or doesn't have atlascloud key\n    }\n  }\n\n  // Check environment variable\n  const envApiKey = process.env.ATLASCLOUD_API_KEY;\n  if (envApiKey) {\n    return {\n      ...DEFAULT_CONFIG,\n      apiKey: envApiKey,\n    };\n  }\n\n  return DEFAULT_CONFIG;\n}\n\nexport function saveConfig(config: AtlasCloudConfig): void {\n  ensureConfigDir();\n  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));\n}\n\nfunction loadOpenCodeAuth(): Record<string, unknown> {\n  if (fs.existsSync(OPENCODE_AUTH_FILE)) {\n    try {\n      const content = fs.readFileSync(OPENCODE_AUTH_FILE, \"utf-8\");\n      return JSON.parse(content);\n    } catch {\n      return {};\n    }\n  }\n  return {};\n}\n\ninterface OpenCodeAuthEntry {\n  type: \"api\";\n  key: string;\n}\n\nfunction saveOpenCodeAuth(auth: Record<string, OpenCodeAuthEntry>): void {\n  ensureOpenCodeAuthDir();\n  fs.writeFileSync(OPENCODE_AUTH_FILE, JSON.stringify(auth, null, 2));\n}\n\nexport function saveApiKey(apiKey: string): void {\n  // Save to our own config\n  const config = loadConfig();\n  config.apiKey = apiKey;\n  saveConfig(config);\n\n  // Save to OpenCode's auth.json in the correct format\n  const existingAuth = loadOpenCodeAuth();\n  const auth: Record<string, OpenCodeAuthEntry> = {};\n\n  // Preserve existing entries (convert if needed)\n  for (const [key, value] of Object.entries(existingAuth)) {\n    if (typeof value === \"object\" && value !== null && (value as any).type === \"api\") {\n      auth[key] = value as OpenCodeAuthEntry;\n    }\n  }\n\n  // Add/update atlascloud entry\n  auth.atlascloud = {\n    type: \"api\",\n    key: apiKey,\n  };\n\n  saveOpenCodeAuth(auth);\n}\n\nexport function getApiKey(): string | undefined {\n  return loadConfig().apiKey;\n}\n\nexport function clearApiKey(): void {\n  // Clear from our config\n  const config = loadConfig();\n  delete config.apiKey;\n  saveConfig(config);\n\n  // Also clear from OpenCode's auth.json\n  if (fs.existsSync(OPENCODE_AUTH_FILE)) {\n    try {\n      const content = fs.readFileSync(OPENCODE_AUTH_FILE, \"utf-8\");\n      const authData = JSON.parse(content);\n      delete authData.atlascloud;\n      ensureOpenCodeAuthDir();\n      fs.writeFileSync(OPENCODE_AUTH_FILE, JSON.stringify(authData, null, 2));\n    } catch {\n      // Ignore errors\n    }\n  }\n}\n"]}

package/dist/server/models.d.ts

@@ -0,0 +1,18 @@
+export interface AtlasCloudModel {
+    id: string;
+    name: string;
+    context: number;
+    output: number;
+}
+export interface OpenCodeModel {
+    name: string;
+    limit: {
+        context: number;
+        output: number;
+    };
+}
+declare const ATLAS_CLOUD_API_BASE = "https://api.atlascloud.ai/v1";
+export declare function fetchModels(apiKey?: string): Promise<AtlasCloudModel[]>;
+export declare function modelsToOpenCodeFormat(models: AtlasCloudModel[]): Record<string, OpenCodeModel>;
+export declare function validateApiKey(apiKey: string): Promise<boolean>;
+export { ATLAS_CLOUD_API_BASE };

package/dist/server/models.js

@@ -0,0 +1,185 @@
+import { getApiKey } from "./config.js";
+const ATLAS_CLOUD_API_BASE = "https://api.atlascloud.ai/v1";
+// Fallback models - use actual Atlas Cloud model IDs (verified from API)
+const FALLBACK_MODELS = [
+    // OpenAI models
+    { id: "openai/gpt-4o", name: "GPT-4o", context: 128000, output: 16384 },
+    { id: "openai/gpt-4o-mini", name: "GPT-4o Mini", context: 128000, output: 16384 },
+    { id: "openai/gpt-4.1", name: "GPT-4.1", context: 128000, output: 16384 },
+    { id: "openai/gpt-4.1-mini", name: "GPT-4.1 Mini", context: 128000, output: 16384 },
+    { id: "openai/gpt-5", name: "GPT-5", context: 200000, output: 32768 },
+    { id: "openai/gpt-5-mini", name: "GPT-5 Mini", context: 128000, output: 16384 },
+    { id: "openai/o1", name: "O1", context: 200000, output: 100000 },
+    { id: "openai/o3", name: "O3", context: 200000, output: 100000 },
+    { id: "openai/o3-mini", name: "O3 Mini", context: 200000, output: 65536 },
+    // Anthropic models
+    { id: "anthropic/claude-sonnet-4.5-20250929", name: "Claude Sonnet 4.5", context: 200000, output: 16384 },
+    { id: "anthropic/claude-opus-4.5-20251101", name: "Claude Opus 4.5", context: 200000, output: 16384 },
+    { id: "anthropic/claude-haiku-4.5-20251001", name: "Claude Haiku 4.5", context: 200000, output: 8192 },
+    { id: "anthropic/claude-haiku-4.5-20251001-developer", name: "Claude Haiku 4.5 Developer", context: 200000, output: 8192 },
+    { id: "anthropic/claude-3.7-sonnet-20250219", name: "Claude 3.7 Sonnet", context: 200000, output: 8192 },
+    // Google models
+    { id: "google/gemini-2.5-flash", name: "Gemini 2.5 Flash", context: 1000000, output: 8192 },
+    { id: "google/gemini-2.5-flash-lite", name: "Gemini 2.5 Flash Lite", context: 1000000, output: 8192 },
+    { id: "google/gemini-2.5-pro", name: "Gemini 2.5 Pro", context: 2000000, output: 8192 },
+    { id: "google/gemini-3-flash-preview", name: "Gemini 3 Flash Preview", context: 2000000, output: 16384 },
+    { id: "google/gemini-3-pro-preview", name: "Gemini 3 Pro Preview", context: 2000000, output: 32768 },
+    // DeepSeek models
+    { id: "deepseek-ai/DeepSeek-V3.1", name: "DeepSeek V3.1", context: 128000, output: 8192 },
+    { id: "deepseek-ai/deepseek-v3.2-speciale", name: "DeepSeek V3.2 Speciale", context: 128000, output: 8192 },
+    { id: "deepseek-ai/deepseek-v3.2", name: "DeepSeek V3.2", context: 128000, output: 8192 },
+    { id: "deepseek-ai/deepseek-r1-0528", name: "DeepSeek R1", context: 128000, output: 8192 },
+    // xAI models
+    { id: "xai/grok-4-0709", name: "Grok 4", context: 128000, output: 16384 },
+];
+function getModelContextLength(modelId) {
+    const id = modelId.toLowerCase();
+    // Anthropic models
+    if (id.includes("claude"))
+        return 200000;
+    // OpenAI models
+    if (id.includes("o1") || id.includes("o3") || id.includes("gpt-5"))
+        return 200000;
+    if (id.includes("gpt-4"))
+        return 128000;
+    if (id.includes("gpt-3.5"))
+        return 16385;
+    // Google models
+    if (id.includes("gemini-3"))
+        return 2000000;
+    if (id.includes("gemini-2.5"))
+        return 1000000;
+    if (id.includes("gemini"))
+        return 128000;
+    // DeepSeek models
+    if (id.includes("deepseek"))
+        return 128000;
+    // xAI models
+    if (id.includes("grok"))
+        return 128000;
+    // Llama models
+    if (id.includes("llama-3.1-405b") || id.includes("llama-3.1-70b"))
+        return 128000;
+    if (id.includes("llama"))
+        return 8192;
+    // Mistral models
+    if (id.includes("mistral-large") || id.includes("mixtral"))
+        return 32768;
+    if (id.includes("mistral"))
+        return 8192;
+    // Qwen models
+    if (id.includes("qwen3"))
+        return 128000;
+    if (id.includes("qwen"))
+        return 32768;
+    return 128000; // Default context length - more generous default
+}
+function getModelOutputTokens(modelId) {
+    const id = modelId.toLowerCase();
+    // Reasoning models with large output
+    if (id.includes("o1") || id.includes("o3"))
+        return 100000;
+    if (id.includes("deepseek-r1") || id.includes("thinking"))
+        return 65536;
+    // Large output models
+    if (id.includes("gpt-5") && !id.includes("mini") && !id.includes("nano"))
+        return 32768;
+    if (id.includes("gemini-3-pro"))
+        return 32768;
+    // Standard large output
+    if (id.includes("gpt-4o") || id.includes("gpt-4.1") || id.includes("gpt-5"))
+        return 16384;
+    if (id.includes("claude-sonnet-4") || id.includes("claude-opus-4"))
+        return 16384;
+    if (id.includes("gemini-3"))
+        return 16384;
+    if (id.includes("grok-4"))
+        return 16384;
+    // Standard output
+    if (id.includes("claude"))
+        return 8192;
+    if (id.includes("gemini"))
+        return 8192;
+    if (id.includes("deepseek"))
+        return 8192;
+    if (id.includes("gpt"))
+        return 8192;
+    if (id.includes("qwen"))
+        return 8192;
+    return 8192; // Default output tokens
+}
+function formatModelName(modelId) {
+    // Capitalize and format model names nicely
+    return modelId
+        .split("-")
+        .map((part) => {
+        if (part.match(/^\d/))
+            return part; // Keep version numbers as-is
+        return part.charAt(0).toUpperCase() + part.slice(1);
+    })
+        .join(" ")
+        .replace(/\s+(\d)/g, "-$1"); // Join version numbers with dash
+}
+export async function fetchModels(apiKey) {
+    const key = apiKey || getApiKey();
+    if (!key) {
+        return FALLBACK_MODELS;
+    }
+    try {
+        const response = await fetch(`${ATLAS_CLOUD_API_BASE}/models`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${key}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!response.ok) {
+            console.error(`Failed to fetch models: ${response.status} ${response.statusText}`);
+            return FALLBACK_MODELS;
+        }
+        const data = (await response.json());
+        if (!data.data || !Array.isArray(data.data)) {
+            return FALLBACK_MODELS;
+        }
+        return data.data.map((model) => ({
+            id: model.id,
+            name: formatModelName(model.id),
+            context: getModelContextLength(model.id),
+            output: getModelOutputTokens(model.id),
+        }));
+    }
+    catch (error) {
+        console.error("Error fetching models:", error);
+        return FALLBACK_MODELS;
+    }
+}
+export function modelsToOpenCodeFormat(models) {
+    const result = {};
+    for (const model of models) {
+        result[model.id] = {
+            name: model.name,
+            limit: {
+                context: model.context,
+                output: model.output,
+            },
+        };
+    }
+    return result;
+}
+export async function validateApiKey(apiKey) {
+    try {
+        const response = await fetch(`${ATLAS_CLOUD_API_BASE}/models`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+        });
+        return response.ok;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export { ATLAS_CLOUD_API_BASE };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"models.js","sourceRoot":"","sources":["../../src/server/models.ts"],"names":[],"mappings":"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","sourcesContent":["import { getApiKey } from \"./config.js\";\n\nexport interface AtlasCloudModel {\n  id: string;\n  name: string;\n  context: number;\n  output: number;\n}\n\nexport interface OpenCodeModel {\n  name: string;\n  limit: {\n    context: number;\n    output: number;\n  };\n}\n\nconst ATLAS_CLOUD_API_BASE = \"https://api.atlascloud.ai/v1\";\n\n// Fallback models - use actual Atlas Cloud model IDs (verified from API)\nconst FALLBACK_MODELS: AtlasCloudModel[] = [\n  // OpenAI models\n  { id: \"openai/gpt-4o\", name: \"GPT-4o\", context: 128000, output: 16384 },\n  { id: \"openai/gpt-4o-mini\", name: \"GPT-4o Mini\", context: 128000, output: 16384 },\n  { id: \"openai/gpt-4.1\", name: \"GPT-4.1\", context: 128000, output: 16384 },\n  { id: \"openai/gpt-4.1-mini\", name: \"GPT-4.1 Mini\", context: 128000, output: 16384 },\n  { id: \"openai/gpt-5\", name: \"GPT-5\", context: 200000, output: 32768 },\n  { id: \"openai/gpt-5-mini\", name: \"GPT-5 Mini\", context: 128000, output: 16384 },\n  { id: \"openai/o1\", name: \"O1\", context: 200000, output: 100000 },\n  { id: \"openai/o3\", name: \"O3\", context: 200000, output: 100000 },\n  { id: \"openai/o3-mini\", name: \"O3 Mini\", context: 200000, output: 65536 },\n  // Anthropic models\n  { id: \"anthropic/claude-sonnet-4.5-20250929\", name: \"Claude Sonnet 4.5\", context: 200000, output: 16384 },\n  { id: \"anthropic/claude-opus-4.5-20251101\", name: \"Claude Opus 4.5\", context: 200000, output: 16384 },\n  { id: \"anthropic/claude-haiku-4.5-20251001\", name: \"Claude Haiku 4.5\", context: 200000, output: 8192 },\n  { id: \"anthropic/claude-haiku-4.5-20251001-developer\", name: \"Claude Haiku 4.5 Developer\", context: 200000, output: 8192 },\n  { id: \"anthropic/claude-3.7-sonnet-20250219\", name: \"Claude 3.7 Sonnet\", context: 200000, output: 8192 },\n  // Google models\n  { id: \"google/gemini-2.5-flash\", name: \"Gemini 2.5 Flash\", context: 1000000, output: 8192 },\n  { id: \"google/gemini-2.5-flash-lite\", name: \"Gemini 2.5 Flash Lite\", context: 1000000, output: 8192 },\n  { id: \"google/gemini-2.5-pro\", name: \"Gemini 2.5 Pro\", context: 2000000, output: 8192 },\n  { id: \"google/gemini-3-flash-preview\", name: \"Gemini 3 Flash Preview\", context: 2000000, output: 16384 },\n  { id: \"google/gemini-3-pro-preview\", name: \"Gemini 3 Pro Preview\", context: 2000000, output: 32768 },\n  // DeepSeek models\n  { id: \"deepseek-ai/DeepSeek-V3.1\", name: \"DeepSeek V3.1\", context: 128000, output: 8192 },\n  { id: \"deepseek-ai/deepseek-v3.2-speciale\", name: \"DeepSeek V3.2 Speciale\", context: 128000, output: 8192 },\n  { id: \"deepseek-ai/deepseek-v3.2\", name: \"DeepSeek V3.2\", context: 128000, output: 8192 },\n  { id: \"deepseek-ai/deepseek-r1-0528\", name: \"DeepSeek R1\", context: 128000, output: 8192 },\n  // xAI models\n  { id: \"xai/grok-4-0709\", name: \"Grok 4\", context: 128000, output: 16384 },\n];\n\ninterface ApiModel {\n  id: string;\n  object?: string;\n  created?: number;\n  owned_by?: string;\n}\n\ninterface ModelsResponse {\n  object?: string;\n  data: ApiModel[];\n}\n\nfunction getModelContextLength(modelId: string): number {\n  const id = modelId.toLowerCase();\n\n  // Anthropic models\n  if (id.includes(\"claude\")) return 200000;\n\n  // OpenAI models\n  if (id.includes(\"o1\") || id.includes(\"o3\") || id.includes(\"gpt-5\")) return 200000;\n  if (id.includes(\"gpt-4\")) return 128000;\n  if (id.includes(\"gpt-3.5\")) return 16385;\n\n  // Google models\n  if (id.includes(\"gemini-3\")) return 2000000;\n  if (id.includes(\"gemini-2.5\")) return 1000000;\n  if (id.includes(\"gemini\")) return 128000;\n\n  // DeepSeek models\n  if (id.includes(\"deepseek\")) return 128000;\n\n  // xAI models\n  if (id.includes(\"grok\")) return 128000;\n\n  // Llama models\n  if (id.includes(\"llama-3.1-405b\") || id.includes(\"llama-3.1-70b\")) return 128000;\n  if (id.includes(\"llama\")) return 8192;\n\n  // Mistral models\n  if (id.includes(\"mistral-large\") || id.includes(\"mixtral\")) return 32768;\n  if (id.includes(\"mistral\")) return 8192;\n\n  // Qwen models\n  if (id.includes(\"qwen3\")) return 128000;\n  if (id.includes(\"qwen\")) return 32768;\n\n  return 128000; // Default context length - more generous default\n}\n\nfunction getModelOutputTokens(modelId: string): number {\n  const id = modelId.toLowerCase();\n\n  // Reasoning models with large output\n  if (id.includes(\"o1\") || id.includes(\"o3\")) return 100000;\n  if (id.includes(\"deepseek-r1\") || id.includes(\"thinking\")) return 65536;\n\n  // Large output models\n  if (id.includes(\"gpt-5\") && !id.includes(\"mini\") && !id.includes(\"nano\")) return 32768;\n  if (id.includes(\"gemini-3-pro\")) return 32768;\n\n  // Standard large output\n  if (id.includes(\"gpt-4o\") || id.includes(\"gpt-4.1\") || id.includes(\"gpt-5\")) return 16384;\n  if (id.includes(\"claude-sonnet-4\") || id.includes(\"claude-opus-4\")) return 16384;\n  if (id.includes(\"gemini-3\")) return 16384;\n  if (id.includes(\"grok-4\")) return 16384;\n\n  // Standard output\n  if (id.includes(\"claude\")) return 8192;\n  if (id.includes(\"gemini\")) return 8192;\n  if (id.includes(\"deepseek\")) return 8192;\n  if (id.includes(\"gpt\")) return 8192;\n  if (id.includes(\"qwen\")) return 8192;\n\n  return 8192; // Default output tokens\n}\n\nfunction formatModelName(modelId: string): string {\n  // Capitalize and format model names nicely\n  return modelId\n    .split(\"-\")\n    .map((part) => {\n      if (part.match(/^\\d/)) return part; // Keep version numbers as-is\n      return part.charAt(0).toUpperCase() + part.slice(1);\n    })\n    .join(\" \")\n    .replace(/\\s+(\\d)/g, \"-$1\"); // Join version numbers with dash\n}\n\nexport async function fetchModels(\n  apiKey?: string\n): Promise<AtlasCloudModel[]> {\n  const key = apiKey || getApiKey();\n\n  if (!key) {\n    return FALLBACK_MODELS;\n  }\n\n  try {\n    const response = await fetch(`${ATLAS_CLOUD_API_BASE}/models`, {\n      method: \"GET\",\n      headers: {\n        Authorization: `Bearer ${key}`,\n        \"Content-Type\": \"application/json\",\n      },\n    });\n\n    if (!response.ok) {\n      console.error(\n        `Failed to fetch models: ${response.status} ${response.statusText}`\n      );\n      return FALLBACK_MODELS;\n    }\n\n    const data = (await response.json()) as ModelsResponse;\n\n    if (!data.data || !Array.isArray(data.data)) {\n      return FALLBACK_MODELS;\n    }\n\n    return data.data.map((model: ApiModel) => ({\n      id: model.id,\n      name: formatModelName(model.id),\n      context: getModelContextLength(model.id),\n      output: getModelOutputTokens(model.id),\n    }));\n  } catch (error) {\n    console.error(\"Error fetching models:\", error);\n    return FALLBACK_MODELS;\n  }\n}\n\nexport function modelsToOpenCodeFormat(\n  models: AtlasCloudModel[]\n): Record<string, OpenCodeModel> {\n  const result: Record<string, OpenCodeModel> = {};\n\n  for (const model of models) {\n    result[model.id] = {\n      name: model.name,\n      limit: {\n        context: model.context,\n        output: model.output,\n      },\n    };\n  }\n\n  return result;\n}\n\nexport async function validateApiKey(apiKey: string): Promise<boolean> {\n  try {\n    const response = await fetch(`${ATLAS_CLOUD_API_BASE}/models`, {\n      method: \"GET\",\n      headers: {\n        Authorization: `Bearer ${apiKey}`,\n        \"Content-Type\": \"application/json\",\n      },\n    });\n\n    return response.ok;\n  } catch (error) {\n    return false;\n  }\n}\n\nexport { ATLAS_CLOUD_API_BASE };\n"]}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@atlascloudai/opencode",
+  "version": "0.0.1",
+  "description": "OpenCode plugin for Atlas Cloud - Access 100+ AI models including GPT-4o, Claude, Gemini, DeepSeek via OpenAI-compatible API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "bin": {
+    "atlascloudai-opencode": "./bin/setup.cjs"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "atlascloud",
+    "atlas-cloud",
+    "ai",
+    "llm",
+    "gpt-4",
+    "claude",
+    "gemini",
+    "deepseek",
+    "openai-compatible"
+  ],
+  "author": "Atlas Cloud",
+  "license": "MIT",
+  "homepage": "https://github.com/atlascloud/opencode-plugin#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/atlascloud/opencode-plugin.git"
+  },
+  "bugs": {
+    "url": "https://github.com/atlascloud/opencode-plugin/issues"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.0.85",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}