opencode-websearch-deepseek 0.2.0 → 0.3.0

package/README.md

@@ -77,6 +77,34 @@ in:
 > so no environment variable is required when that provider is already
 > authenticated.
 
+### Plugin options
+
+As an alternative to environment variables, configure the plugin with the
+`plugins` object form (read from `ctx.options`):
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugins": [
+    {
+      "package": "opencode-websearch-deepseek",
+      "options": {
+        "apiKey": "{file:~/.config/opencode/deepseek.key}",
+        "model": "deepseek-v4-flash",
+        "maxUses": 5,
+        "thinking": "enabled"
+      }
+    }
+  ]
+}
+```
+
+Precedence for the API key: `options.apiKey` → `DEEPSEEK_API_KEY` /
+`WEBSEARCH_API_KEY` → stored `deepseek` provider credential. `model`, `maxUses`,
+and `thinking` fall back to their environment variables and defaults.
+OpenCode interpolates `{file:...}` (and `{env:...}`) in config values, so the
+key can live in a file instead of the OS environment.
+
 > The plugin always selects the DeepSeek provider. Without an API key, a
 > `websearch` call fails with a clear error rather than silently falling back
 > to a different provider.

package/dist/index.d.ts

@@ -95,25 +95,48 @@ export interface IntegrationContext {
         resolve(connection: unknown): Promise<StoredCredential | undefined>;
     };
 }
+/**
+ * Options accepted through the `plugins` object form in `opencode.json(c)` and
+ * forwarded to the plugin via `ctx.options`:
+ *
+ * ```jsonc
+ * { "plugins": [{ "package": "opencode-websearch-deepseek", "options": {
+ *   "apiKey": "...", "model": "deepseek-v4-flash", "maxUses": 5, "thinking": "enabled"
+ * } }] }
+ * ```
+ */
+export interface WebsearchOptions {
+    /** DeepSeek API key; takes precedence over env and the stored credential. */
+    apiKey?: string;
+    /** Model used for search and synthesis. */
+    model?: string;
+    /** Max server-side searches per query. */
+    maxUses?: number | string;
+    /** `enabled` or `disabled`. */
+    thinking?: string;
+}
 /** Context passed to the plugin's `setup`. */
 export interface WebsearchContext {
     websearch: {
         transform(callback: (editor: WebsearchEditor) => void): Promise<unknown> | unknown;
     };
+    /** Plugin options from the `plugins` object form. */
+    options?: Record<string, unknown>;
     /** Present in OpenCode 2.x; used to reuse the DeepSeek provider credential. */
     integration?: IntegrationContext;
 }
 /**
- * Resolve the DeepSeek API key. An explicit environment variable takes
- * precedence; otherwise the key OpenCode stores for the `deepseek` provider
- * (configured via `opencode auth login`) is used.
+ * Resolve the DeepSeek API key, in order of precedence: the `apiKey` plugin
+ * option, then the `DEEPSEEK_API_KEY`/`WEBSEARCH_API_KEY` environment
+ * variables, then the credential OpenCode stores for the `deepseek` provider
+ * (configured via `opencode auth login`).
  */
-export declare function resolveApiKey(ctx: WebsearchContext): Promise<string | undefined>;
+export declare function resolveApiKey(ctx: WebsearchContext, options?: WebsearchOptions): Promise<string | undefined>;
 /**
  * Resolve the `max_uses` value for the search tool declaration.
  * Falls back to {@link DEFAULT_MAX_USES} for missing or invalid input.
  */
-export declare function resolveMaxUses(raw?: string | undefined): number;
+export declare function resolveMaxUses(raw?: string | number | undefined): number;
 /**
  * Resolve the thinking mode. Only `disabled` disables extended thinking;
  * anything else (including unset) keeps the historical `enabled` behavior.

package/dist/index.js

@@ -46,12 +46,20 @@ export const SYSTEM_PROMPT = [
     "",
     "Your response must be the final answer, not another search request.",
 ].join("\n");
+/** Return a trimmed non-empty string, or undefined for any other value. */
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
 /**
- * Resolve the DeepSeek API key. An explicit environment variable takes
- * precedence; otherwise the key OpenCode stores for the `deepseek` provider
- * (configured via `opencode auth login`) is used.
+ * Resolve the DeepSeek API key, in order of precedence: the `apiKey` plugin
+ * option, then the `DEEPSEEK_API_KEY`/`WEBSEARCH_API_KEY` environment
+ * variables, then the credential OpenCode stores for the `deepseek` provider
+ * (configured via `opencode auth login`).
  */
-export async function resolveApiKey(ctx) {
+export async function resolveApiKey(ctx, options) {
+    const fromOptions = readString(options?.apiKey);
+    if (fromOptions)
+        return fromOptions;
     const fromEnv = readEnv("DEEPSEEK_API_KEY") ?? readEnv("WEBSEARCH_API_KEY");
     if (fromEnv)
         return fromEnv;
@@ -97,6 +105,9 @@ function throwCancellation(signal, fallback) {
  * Falls back to {@link DEFAULT_MAX_USES} for missing or invalid input.
  */
 export function resolveMaxUses(raw = process.env.WEBSEARCH_MAX_USES) {
+    if (typeof raw === "number") {
+        return Number.isSafeInteger(raw) && raw > 0 ? raw : DEFAULT_MAX_USES;
+    }
     const value = (typeof raw === "string" ? raw : "").trim();
     // Strict: only a plain positive integer. Rejects "1e3", "5.5", "5abc" and
     // values outside the safe-integer range (e.g. a 24-digit number).
@@ -230,22 +241,23 @@ export function toResults(answer, sources = []) {
 export const plugin = {
     id: "websearch.deepseek",
     async setup(ctx) {
+        const options = (ctx.options ?? {});
         await ctx.websearch.transform((editor) => {
             editor.add({
                 id: "deepseek",
                 name: "DeepSeek Web Search",
                 execute: async ({ query }, { signal } = {}) => {
-                    const apiKey = await resolveApiKey(ctx);
+                    const apiKey = await resolveApiKey(ctx, options);
                     if (!apiKey) {
-                        throw new Error("DEEPSEEK_API_KEY is not set and no stored DeepSeek credential was found; set the env var or sign in to the deepseek provider in OpenCode");
+                        throw new Error("No DeepSeek API key: set the DEEPSEEK_API_KEY env var, pass the apiKey plugin option, or sign in to the deepseek provider in OpenCode");
                     }
                     if (!/^[\x21-\x7e]+$/.test(apiKey)) {
                         throw new Error("The API key contains invalid characters");
                     }
                     const body = buildRequestBody(query, {
-                        model: readEnv("WEBSEARCH_MODEL") ?? DEFAULT_MODEL,
-                        maxUses: resolveMaxUses(),
-                        thinking: resolveThinking(),
+                        model: readString(options.model) ?? readEnv("WEBSEARCH_MODEL") ?? DEFAULT_MODEL,
+                        maxUses: resolveMaxUses(options.maxUses ?? readEnv("WEBSEARCH_MAX_USES")),
+                        thinking: resolveThinking(readString(options.thinking) ?? readEnv("WEBSEARCH_THINKING")),
                     });
                     const response = await fetch(API_URL, {
                         method: "POST",

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-websearch-deepseek",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "DeepSeek-powered web search provider for OpenCode's built-in websearch tool.",
   "type": "module",
   "license": "MIT",