opencode-cmd-provider 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 - 2026-08-15
+
+Initial release: Command Code provider + plugin for opencode.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 opencode-cmd-provider contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,172 @@
+# opencode-cmd-provider
+
+[![CI](https://github.com/rashidrazak/opencode-cmd-provider/actions/workflows/ci.yml/badge.svg)](https://github.com/rashidrazak/opencode-cmd-provider/actions/workflows/ci.yml)
+
+A provider and plugin for [opencode](https://opencode.ai) that connects to the [Command Code](https://commandcode.ai) Provider API.
+
+> **Disclaimer:** This is an unofficial, community-maintained integration. It is not affiliated with, endorsed by, or supported by Command Code. You need your own Command Code account and API key or subscription. Command Code's terms, availability, and pricing apply.
+
+## Install
+
+Add the package to your opencode configuration:
+
+```jsonc
+// opencode.json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["opencode-cmd-provider"],
+  "provider": {
+    "commandcode": {
+      "npm": "opencode-cmd-provider",
+      "name": "Command Code",
+      "options": { "baseURL": "https://api.commandcode.ai" },
+      "models": {
+        "claude-sonnet-5": {
+          "name": "Claude Sonnet 5",
+          "limit": { "context": 200000, "output": 65536 },
+        },
+      },
+    },
+  },
+}
+```
+
+> **The `models` map is required.** opencode only fires a provider's `models`
+> discovery hook for providers already in its [models.dev](https://models.dev)
+> catalog, and `commandcode` is not in that catalog yet. Declaring the models you
+> want in `provider.commandcode.models` is what makes them appear in `/models`
+> and usable with `opencode run --model commandcode/...`. The reference config is
+> the one written by `scripts/opencode-fixture.mjs`. When `commandcode` lands in
+> the models.dev catalog, this map becomes optional and discovery works via the
+> plugin's `provider.models` hook.
+
+Start or reload opencode, then authenticate:
+
+```txt
+/connect
+```
+
+Select **Command Code**, complete the browser flow, and pick a model with `/models`.
+
+## Authentication
+
+### Browser login
+
+Run `/connect` in opencode and select **Command Code**. The browser flow stores the returned credential in opencode's auth store.
+
+If automatic transfer from the browser fails, copy the API key shown by Command Code and export it as `COMMANDCODE_API_KEY` (see below).
+
+### Environment variable
+
+```sh
+export COMMANDCODE_API_KEY="user_..."
+```
+
+### Legacy auth files
+
+The provider also reads existing credentials from:
+
+- `~/.commandcode/auth.json`
+- `~/.omp/agent/auth.json`
+- `~/.pi/agent/auth.json`
+
+Supported examples:
+
+```json
+{
+  "apiKey": "user_..."
+}
+```
+
+```json
+{
+  "command-code": {
+    "type": "api",
+    "key": "user_..."
+  }
+}
+```
+
+```json
+{
+  "commandcode": "user_..."
+}
+```
+
+## Usage
+
+Pick a model with `/models`, or run non-interactively:
+
+```sh
+opencode run --model commandcode/claude-sonnet-5 "hello"
+```
+
+Model availability changes over time and is refreshed from the Command Code catalog when opencode loads.
+
+### Reasoning support
+
+Reasoning metadata is enriched only for models whose Command Code effort support is known. Supported levels are sent as the documented `reasoning_effort` request field; `off`, unsupported levels, and newly discovered models without metadata do not add reasoning fields to the request. No prompt instructions are injected.
+
+Reasoning blocks from completed assistant turns are not replayed to Command Code in later requests; only the user-visible text and completed tool calls are sent back as history. This prevents prior private reasoning traces from interfering with reasoning on follow-up turns.
+
+## Model discovery and offline behavior
+
+The provider fetches the current model catalog from:
+
+```txt
+https://api.commandcode.ai/provider/v1/models
+```
+
+The last successful catalog is cached at `<data-dir>/commandcode-models.json`, where `<data-dir>` is opencode's XDG data directory (default `~/.local/share/opencode`).
+
+If the endpoint is temporarily unavailable, the provider uses the cached catalog. On a first offline start without a cache, opencode still starts cleanly, but Command Code models remain unavailable until the connection is restored.
+
+The following environment variables are intended for tests, local mocks, and compatible API endpoints:
+
+| Variable                        | Purpose                                                                                        |
+| ------------------------------- | ---------------------------------------------------------------------------------------------- |
+| `COMMANDCODE_API_BASE`          | Override the Command Code API base URL                                                         |
+| `COMMANDCODE_MODELS_URL`        | Override the model catalog endpoint                                                            |
+| `COMMANDCODE_MODELS_CACHE`      | Override the model cache file path                                                             |
+| `COMMANDCODE_MODELS_TIMEOUT_MS` | Catalog fetch timeout (defaults to 10 seconds; invalid or non-positive values use the default) |
+
+## Image input
+
+Image input is advertised only for models marked with the `image` input modality in the Command Code model catalog. The capability snapshot follows the current official CLI catalog; unknown models default to text-only until their upstream metadata is reviewed.
+
+For vision-capable models, image blocks from user messages and tool results are forwarded in Command Code's data-URL wire format. Text-only models reject image content before making a network request instead of silently dropping it.
+
+## Pricing display
+
+The Command Code Provider API does not currently include prices in its model catalog. This provider keeps a static table for models with known prices so opencode can display estimated request costs.
+
+Models missing from that table display zero cost in opencode. This does **not** mean Command Code will bill the request at zero. Check the current [Command Code pricing](https://commandcode.ai/docs/resources/pricing-limits) before relying on the displayed value.
+
+## Update and remove
+
+Update the installed package, or remove it from the `plugin` array and the `provider.commandcode` block in your `opencode.json`. The npm package is cached under opencode's plugin cache (`~/.cache/opencode/packages/`); remove the cached directory to fully uninstall.
+
+## Development
+
+Build, then run the full suite:
+
+```sh
+npm install
+npm run build
+npm test
+npm run format:check
+```
+
+The headless end-to-end test runs the real opencode CLI against a mock Command Code server through the built package:
+
+```sh
+npm run build && npm run test:e2e
+```
+
+`scripts/opencode-fixture.mjs` writes a throwaway `opencode.json` wiring the local build to the mock endpoints. `test:e2e` is a local dev gate (it needs the real `opencode` binary on PATH) and is excluded from `npm test`.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for local setup and tests. See [RELEASE.md](RELEASE.md) for the release process.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createCommandCode } from "./src/provider/index.js";
+export { default } from "./src/plugin/index.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+// index.ts
+// Dual export: opencode's provider loader scans for the first export whose name
+// starts with "create"; its plugin loader early-returns on a V1 default module.
+// Exactly one create* export + a { id, server } default keeps both loaders safe
+// (see DESIGN.md §4). Enforced by tests/contract.test.ts.
+export { createCommandCode } from "./src/provider/index.js";
+export { default } from "./src/plugin/index.js";

package/dist/src/env.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_API_BASE = "https://api.commandcode.ai";
+export declare const DEFAULT_MODELS_URL = "https://api.commandcode.ai/provider/v1/models";
+export declare const DEFAULT_MODELS_TIMEOUT_MS = 10000;
+export declare function getApiBase(env?: NodeJS.ProcessEnv): string;
+export declare function getModelsUrl(env?: NodeJS.ProcessEnv): string;
+export declare function getModelsTimeoutMs(env?: NodeJS.ProcessEnv): number;
+export declare function getDataDir(env?: NodeJS.ProcessEnv, homeDir?: () => string): string;

package/dist/src/env.js

@@ -0,0 +1,24 @@
+// src/env.ts — COMMANDCODE_* environment overrides with safe defaults (PLAN #2 Part A)
+import { homedir } from "node:os";
+export const DEFAULT_API_BASE = "https://api.commandcode.ai";
+export const DEFAULT_MODELS_URL = "https://api.commandcode.ai/provider/v1/models";
+export const DEFAULT_MODELS_TIMEOUT_MS = 10_000;
+export function getApiBase(env = process.env) {
+    return env.COMMANDCODE_API_BASE ?? DEFAULT_API_BASE;
+}
+export function getModelsUrl(env = process.env) {
+    return env.COMMANDCODE_MODELS_URL ?? DEFAULT_MODELS_URL;
+}
+export function getModelsTimeoutMs(env = process.env) {
+    const raw = env.COMMANDCODE_MODELS_TIMEOUT_MS;
+    if (!raw)
+        return DEFAULT_MODELS_TIMEOUT_MS;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MODELS_TIMEOUT_MS;
+}
+export function getDataDir(env = process.env, homeDir = homedir) {
+    const xdg = env.XDG_DATA_HOME;
+    if (xdg)
+        return xdg;
+    return `${homeDir()}/.local/share/opencode`;
+}

package/dist/src/plugin/auth-server.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Local HTTP callback server for the Command Code browser auth flow.
+ *
+ * Starts a one-shot server on a CLI-compatible localhost port. The Command Code
+ * Studio website POSTs the user's API key to /callback after they authenticate.
+ */
+import { type Server } from "node:http";
+export interface AuthCallback {
+    apiKey: string;
+    state: string;
+    userId: string;
+    userName: string;
+    keyName: string;
+}
+export interface AuthServer {
+    server: Server;
+    port: number;
+    waitForCallback: Promise<AuthCallback>;
+}
+export interface AuthServerOptions {
+    startPort?: number;
+    portRange?: number;
+}
+/**
+ * Start a local HTTP server that listens for the Command Code Studio
+ * to POST the API key after the user authenticates in their browser.
+ *
+ * The server accepts exactly one valid POST to /callback and then closes.
+ */
+export declare function startAuthServer(options?: AuthServerOptions): Promise<AuthServer>;

package/dist/src/plugin/auth-server.js

@@ -0,0 +1,158 @@
+/**
+ * Local HTTP callback server for the Command Code browser auth flow.
+ *
+ * Starts a one-shot server on a CLI-compatible localhost port. The Command Code
+ * Studio website POSTs the user's API key to /callback after they authenticate.
+ */
+import { createServer } from "node:http";
+const DEFAULT_PORT = 5959;
+const DEFAULT_PORT_RANGE = 10;
+function listenOnAvailablePort(server, startPort = DEFAULT_PORT, range = DEFAULT_PORT_RANGE) {
+    return new Promise((resolve, reject) => {
+        let offset = 0;
+        const tryListen = () => {
+            const useFallbackPort = startPort === 0 || offset >= range;
+            const port = useFallbackPort ? 0 : startPort + offset;
+            const onError = (err) => {
+                server.off("listening", onListening);
+                if (err.code === "EADDRINUSE" && !useFallbackPort) {
+                    offset += 1;
+                    tryListen();
+                    return;
+                }
+                reject(err);
+            };
+            const onListening = () => {
+                server.off("error", onError);
+                const address = server.address();
+                resolve(address.port);
+            };
+            server.once("error", onError);
+            server.once("listening", onListening);
+            server.listen(port, "127.0.0.1");
+        };
+        tryListen();
+    });
+}
+function closeServer(server) {
+    server.close((err) => {
+        if (err && err.code !== "ERR_SERVER_NOT_RUNNING") {
+            // There is nowhere useful to report this during auth cleanup.
+        }
+    });
+}
+/**
+ * Start a local HTTP server that listens for the Command Code Studio
+ * to POST the API key after the user authenticates in their browser.
+ *
+ * The server accepts exactly one valid POST to /callback and then closes.
+ */
+export async function startAuthServer(options = {}) {
+    let resolveCallback;
+    let rejectCallback;
+    const waitForCallback = new Promise((resolve, reject) => {
+        resolveCallback = resolve;
+        rejectCallback = reject;
+    });
+    const server = createServer((req, res) => {
+        // CORS: allow requests from Command Code domains and localhost for dev.
+        const origin = req.headers.origin || "";
+        const allowedOrigins = [
+            "http://localhost:3000",
+            "https://staging.commandcode.ai",
+            "https://commandcode.ai",
+        ];
+        const responseOrigin = allowedOrigins.includes(origin) ? origin : allowedOrigins[0];
+        const requestedHeaders = req.headers["access-control-request-headers"];
+        const allowHeaders = typeof requestedHeaders === "string" && requestedHeaders.length > 0
+            ? requestedHeaders
+            : "Content-Type";
+        res.setHeader("Access-Control-Allow-Origin", responseOrigin);
+        res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", allowHeaders);
+        // Chrome's Private Network Access preflight may require this for an HTTPS
+        // page posting to a localhost HTTP callback.
+        res.setHeader("Access-Control-Allow-Private-Network", "true");
+        res.setHeader("Content-Type", "application/json");
+        // Handle CORS preflight.
+        if (req.method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (req.url !== "/callback") {
+            res.writeHead(404);
+            res.end(JSON.stringify({ success: false, error: "Not found" }));
+            return;
+        }
+        if (req.method !== "POST") {
+            res.writeHead(405);
+            res.end(JSON.stringify({
+                success: false,
+                error: "Method not allowed. Use POST.",
+            }));
+            return;
+        }
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+            if (body.length > 10_000)
+                req.destroy();
+        });
+        req.on("end", () => {
+            try {
+                const parsed = JSON.parse(body);
+                if (parsed.error) {
+                    res.writeHead(200);
+                    res.end(JSON.stringify({ success: true }));
+                    const description = typeof parsed.error_description === "string"
+                        ? parsed.error_description
+                        : String(parsed.error);
+                    if (parsed.error === "access_denied") {
+                        rejectCallback(new Error(description || "Authorization was denied by the user"));
+                    }
+                    else {
+                        rejectCallback(new Error(description || String(parsed.error)));
+                    }
+                    closeServer(server);
+                    return;
+                }
+                const apiKey = typeof parsed.apiKey === "string" ? parsed.apiKey : "";
+                const state = typeof parsed.state === "string" ? parsed.state : "";
+                const userId = typeof parsed.userId === "string" ? parsed.userId : "";
+                const userName = typeof parsed.userName === "string" ? parsed.userName : "";
+                const keyName = typeof parsed.keyName === "string" ? parsed.keyName : "";
+                if (!apiKey || !state || !userId || !userName || !keyName) {
+                    res.writeHead(400);
+                    res.end(JSON.stringify({
+                        success: false,
+                        error: "Missing required fields",
+                    }));
+                    return;
+                }
+                res.writeHead(200);
+                res.end(JSON.stringify({ success: true }));
+                resolveCallback({ apiKey, state, userId, userName, keyName });
+                closeServer(server);
+            }
+            catch {
+                res.writeHead(400);
+                res.end(JSON.stringify({ success: false, error: "Invalid JSON" }));
+            }
+        });
+        req.on("error", () => {
+            res.writeHead(500);
+            res.end(JSON.stringify({ success: false, error: "Request error" }));
+        });
+    });
+    try {
+        const port = await listenOnAvailablePort(server, options.startPort ?? DEFAULT_PORT, options.portRange ?? DEFAULT_PORT_RANGE);
+        return { server, port, waitForCallback };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = new Error(`Failed to start auth server: ${message}`);
+        rejectCallback(error);
+        throw error;
+    }
+}

package/dist/src/plugin/auth.d.ts

@@ -0,0 +1,6 @@
+import type { AuthOAuthResult } from "@opencode-ai/plugin";
+export interface RunAuthFlowOptions {
+    startPort?: number;
+    timeoutMs?: number;
+}
+export declare function runAuthFlow(options?: RunAuthFlowOptions): Promise<AuthOAuthResult>;

package/dist/src/plugin/auth.js

@@ -0,0 +1,38 @@
+// src/plugin/auth.ts — opencode /connect auth flow (PLAN #10)
+//
+// Wraps the local callback server in the opencode AuthOAuthResult shape:
+// the studio URL is opened in the browser, the studio POSTs the API key to
+// the local /callback endpoint, and callback() resolves with the key.
+import { randomBytes } from "node:crypto";
+import { startAuthServer } from "./auth-server.js";
+const STUDIO_BASE_URL = "https://commandcode.ai";
+const DEFAULT_AUTH_TIMEOUT_MS = 15_000;
+function generateStateToken() {
+    return randomBytes(32).toString("base64url");
+}
+export async function runAuthFlow(options = {}) {
+    const authServer = await startAuthServer({ startPort: options.startPort });
+    const stateToken = generateStateToken();
+    const callbackUrl = `http://localhost:${authServer.port}/callback`;
+    const url = `${STUDIO_BASE_URL}/studio/auth/cli?callback=${encodeURIComponent(callbackUrl)}&state=${encodeURIComponent(stateToken)}`;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_AUTH_TIMEOUT_MS;
+    return {
+        url,
+        instructions: "Complete the flow in your browser. If automatic transfer fails, set COMMANDCODE_API_KEY to the API key shown by Command Code.",
+        method: "auto",
+        callback: async () => {
+            try {
+                const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), timeoutMs));
+                const callback = await Promise.race([authServer.waitForCallback, timeout]);
+                authServer.server.close();
+                if (callback.state !== stateToken)
+                    return { type: "failed" };
+                return { type: "success", key: callback.apiKey };
+            }
+            catch {
+                authServer.server.close();
+                return { type: "failed" };
+            }
+        },
+    };
+}

package/dist/src/plugin/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const _default: {
+    id: string;
+    server: Plugin;
+};
+export default _default;

package/dist/src/plugin/index.js

@@ -0,0 +1,39 @@
+// src/plugin/index.ts — V1 opencode plugin module (PLAN #11)
+import { getApiBase, getModelsUrl, getModelsTimeoutMs, getDataDir } from "../env.js";
+import { loadCommandCodeModels } from "../provider/models.js";
+import { catalogToOpenCodeModels } from "./models.js";
+import { runAuthFlow } from "./auth.js";
+import { join } from "node:path";
+import { mkdirSync } from "node:fs";
+const server = async () => {
+    return {
+        auth: {
+            provider: "commandcode",
+            methods: [
+                {
+                    type: "oauth",
+                    label: "Command Code",
+                    authorize: async () => runAuthFlow(),
+                },
+            ],
+        },
+        provider: {
+            id: "commandcode",
+            models: async () => {
+                const cacheDir = getDataDir();
+                mkdirSync(cacheDir, { recursive: true });
+                const cachePath = process.env.COMMANDCODE_MODELS_CACHE ?? join(cacheDir, "commandcode-models.json");
+                const loaded = await loadCommandCodeModels({
+                    url: getModelsUrl(),
+                    cachePath,
+                    timeoutMs: getModelsTimeoutMs(),
+                });
+                return catalogToOpenCodeModels(loaded.models, {
+                    npm: "opencode-cmd-provider",
+                    url: getApiBase(),
+                });
+            },
+        },
+    };
+};
+export default { id: "commandcode", server };

package/dist/src/plugin/models.d.ts

@@ -0,0 +1,7 @@
+import type { Model } from "@opencode-ai/sdk/v2";
+import type { CommandCodeModel } from "../provider/models.js";
+export interface CatalogMappingOptions {
+    npm: string;
+    url: string;
+}
+export declare function catalogToOpenCodeModels(models: readonly CommandCodeModel[], options: CatalogMappingOptions): Record<string, Model>;

package/dist/src/plugin/models.js

@@ -0,0 +1,50 @@
+import { MODEL_COSTS, ZERO_MODEL_COST } from "../provider/pricing.js";
+import { isReasoningModel, thinkingMetadataForModel } from "../provider/reasoning.js";
+import { inputModalitiesForModel } from "../provider/modalities.js";
+const DEFAULT_MAX_OUTPUT_TOKENS = 65_536;
+export function catalogToOpenCodeModels(models, options) {
+    const out = {};
+    for (const model of models) {
+        const costs = MODEL_COSTS[model.id] ?? ZERO_MODEL_COST;
+        const modalities = inputModalitiesForModel(model.id);
+        out[model.id] = {
+            id: model.id,
+            providerID: "commandcode",
+            api: { id: model.id, url: options.url, npm: options.npm },
+            name: model.name,
+            capabilities: {
+                temperature: false,
+                reasoning: isReasoningModel(model.id),
+                attachment: modalities.includes("image"),
+                toolcall: true,
+                input: {
+                    text: true,
+                    image: modalities.includes("image"),
+                    audio: false,
+                    video: false,
+                    pdf: false,
+                },
+                output: { text: true, audio: false, image: false, video: false, pdf: false },
+                interleaved: false,
+            },
+            cost: {
+                input: costs.input,
+                output: costs.output,
+                cache: { read: costs.cacheRead, write: costs.cacheWrite },
+            },
+            limit: {
+                context: model.contextWindow,
+                output: Math.min(model.contextWindow, DEFAULT_MAX_OUTPUT_TOKENS),
+            },
+            status: "active",
+            options: {
+                ...(thinkingMetadataForModel(model.id)
+                    ? { thinking: thinkingMetadataForModel(model.id) }
+                    : {}),
+            },
+            headers: {},
+            release_date: "",
+        };
+    }
+    return out;
+}

package/dist/src/provider/aisdk-types.d.ts

@@ -0,0 +1,9 @@
+import type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3StreamPart, LanguageModelV3Usage, LanguageModelV3Prompt, LanguageModelV3DataContent, LanguageModelV3FunctionTool } from "@ai-sdk/provider";
+export type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3StreamPart, LanguageModelV3Usage, LanguageModelV3Prompt, LanguageModelV3DataContent, LanguageModelV3FunctionTool, };
+/**
+ * Call options for doStream/doGenerate. The installed @ai-sdk/provider (3.x)
+ * exports LanguageModelV3CallOptions directly, so this is a plain alias.
+ * (The plan sketched a local shape with a `mode` field — that is the v2-era
+ * shape; v3 call options have no `mode`.)
+ */
+export type ModelCallOptions = LanguageModelV3CallOptions;

package/dist/src/provider/aisdk-types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/provider/auth-key.d.ts

@@ -0,0 +1,7 @@
+export interface AuthKeyOptions {
+    apiKey?: string;
+    env?: NodeJS.ProcessEnv;
+    authPaths?: readonly string[];
+    homeDir?: () => string;
+}
+export declare function resolveApiKey(options?: AuthKeyOptions): string | undefined;