opencode-websearch-deepseek 0.3.0 → 0.3.2

package/dist/index.d.ts

@@ -131,7 +131,7 @@ export interface WebsearchContext {
  * variables, then the credential OpenCode stores for the `deepseek` provider
  * (configured via `opencode auth login`).
  */
-export declare function resolveApiKey(ctx: WebsearchContext, options?: WebsearchOptions): Promise<string | undefined>;
+export declare function resolveApiKey(ctx: WebsearchContext, options?: WebsearchOptions, signal?: AbortSignal): 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.

package/dist/index.js

@@ -56,7 +56,7 @@ function readString(value) {
  * variables, then the credential OpenCode stores for the `deepseek` provider
  * (configured via `opencode auth login`).
  */
-export async function resolveApiKey(ctx, options) {
+export async function resolveApiKey(ctx, options, signal) {
     const fromOptions = readString(options?.apiKey);
     if (fromOptions)
         return fromOptions;
@@ -67,15 +67,17 @@ export async function resolveApiKey(ctx, options) {
     if (!integration)
         return undefined;
     try {
-        const connection = await integration.connection.active("deepseek");
+        const connection = await withAbort(integration.connection.active("deepseek"), signal);
         if (!connection)
             return undefined;
-        const credential = await integration.connection.resolve(connection);
-        const key = credential?.key;
-        return typeof key === "string" && key.trim() ? key.trim() : undefined;
+        const credential = await withAbort(integration.connection.resolve(connection), signal);
+        return readString(credential?.key);
     }
-    catch {
-        return undefined;
+    catch (error) {
+        if (signal?.aborted)
+            throwCancellation(signal, error);
+        // A genuine integration failure is not "no key": surface it with context.
+        throw new Error("Failed to read the DeepSeek credential from OpenCode", { cause: error });
     }
 }
 /** Read an environment variable, treating blank strings as unset. */
@@ -84,47 +86,108 @@ function readEnv(name, env = process.env) {
     return value && value.trim() ? value.trim() : undefined;
 }
 /**
- * Rethrow the cancellation reason from `signal`. `Error` and `DOMException`
- * (e.g. `AbortError`) are preserved as-is; other values (primitives) are
+ * Rethrow the cancellation reason from `signal`. `Error` and `AbortError`
+ * objects (e.g. `DOMException`) are preserved as-is; other reasons are
  * normalised to an `Error` so callers always receive one.
  */
 function throwCancellation(signal, fallback) {
     const reason = signal.reason;
     if (reason instanceof Error)
         throw reason;
-    if (typeof reason === "object" && reason !== null)
-        throw reason;
-    if (reason !== undefined && reason !== null)
-        throw new Error(String(reason));
+    if (typeof reason === "object" && reason !== null) {
+        // Preserve AbortError-like objects (DOMException has a message); wrap the
+        // rest. Guard the property reads: a hostile reason may throw from a getter.
+        try {
+            const candidate = reason;
+            if (candidate.name === "AbortError" && typeof candidate.message === "string" && candidate.message) {
+                throw reason;
+            }
+        }
+        catch (error) {
+            if (error === reason)
+                throw error;
+        }
+        throw new Error("The web search was aborted", { cause: reason });
+    }
+    if (typeof reason === "string" && reason.trim())
+        throw new Error(reason.trim());
+    if (reason !== undefined && reason !== null) {
+        // Non-string primitives (e.g. 0) are not useful messages; keep them as cause.
+        throw new Error("The web search was aborted", { cause: reason });
+    }
     if (fallback instanceof Error)
         throw fallback;
     throw new Error("The web search was aborted");
 }
+/** Reject with the signal's reason if `signal` aborts before `promise` settles. */
+function withAbort(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted) {
+        // The passed promise is already created; swallow its later rejection so it
+        // does not surface as an unhandled rejection.
+        promise.catch(() => { });
+        return Promise.reject(signal.reason ?? new Error("The web search was aborted"));
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason ?? new Error("The web search was aborted"));
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}
+/**
+ * Validate a `max_uses` value: a positive safe integer, given as a number or a
+ * plain-integer string. Returns `undefined` when unset or invalid.
+ */
+function pickMaxUses(value) {
+    if (typeof value === "number") {
+        return Number.isSafeInteger(value) && value > 0 ? value : undefined;
+    }
+    if (typeof value !== "string")
+        return undefined;
+    // Strict: only a plain positive integer. Rejects "1e3", "5.5", "5abc" and
+    // values outside the safe-integer range (e.g. a 24-digit number).
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed))
+        return undefined;
+    const parsed = Number(trimmed);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
 /**
  * Resolve the `max_uses` value for the search tool declaration.
  * 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;
+    return pickMaxUses(raw) ?? DEFAULT_MAX_USES;
+}
+/**
+ * Validate a thinking mode: only recognised `enabled`/`disabled` spellings
+ * count. Returns `undefined` when unset or unrecognised.
+ */
+function pickThinking(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "enabled" || normalized === "on" || normalized === "true" || normalized === "1") {
+        return "enabled";
     }
-    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).
-    if (!/^\d+$/.test(value))
-        return DEFAULT_MAX_USES;
-    const parsed = Number(value);
-    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_USES;
+    if (normalized === "disabled" || normalized === "off" || normalized === "false" || normalized === "0") {
+        return "disabled";
+    }
+    return undefined;
 }
 /**
  * Resolve the thinking mode. Only `disabled` disables extended thinking;
  * anything else (including unset) keeps the historical `enabled` behavior.
  */
 export function resolveThinking(raw = process.env.WEBSEARCH_THINKING) {
-    const value = (typeof raw === "string" ? raw : "").trim().toLowerCase();
-    return value === "disabled" || value === "off" || value === "false" || value === "0"
-        ? "disabled"
-        : "enabled";
+    return pickThinking(raw) ?? "enabled";
 }
 /** Build the JSON request body sent to the DeepSeek Messages endpoint. */
 export function buildRequestBody(query, options) {
@@ -154,7 +217,7 @@ export function buildRequestBody(query, options) {
  */
 export function dedupeSources(sources) {
     const byUrl = new Map();
-    for (const source of sources) {
+    for (const source of Array.isArray(sources) ? sources : []) {
         if (typeof source?.url !== "string" || source.url.length === 0)
             continue;
         const existing = byUrl.get(source.url);
@@ -210,16 +273,19 @@ export function extractAnswerAndSources(data) {
  * present), followed by the individual sources.
  */
 export function toResults(answer, sources = []) {
+    const valid = (Array.isArray(sources) ? sources : []).filter((source) => typeof source?.url === "string" && source.url.length > 0);
     const results = [];
     if (answer) {
+        // The synthesized answer reuses the first source's URL so it links to a
+        // real page; the same source is also listed below (intentional).
         results.push({
-            url: sources[0]?.url ?? FALLBACK_URL,
+            url: valid[0]?.url ?? FALLBACK_URL,
             title: "DeepSeek answer",
             content: answer,
             time: {},
         });
     }
-    for (const source of sources) {
+    for (const source of valid) {
         results.push({
             url: source.url,
             title: source.title || source.url,
@@ -246,47 +312,62 @@ export const plugin = {
             editor.add({
                 id: "deepseek",
                 name: "DeepSeek Web Search",
-                execute: async ({ query }, { signal } = {}) => {
-                    const apiKey = await resolveApiKey(ctx, options);
-                    if (!apiKey) {
-                        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: 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",
-                        signal,
-                        headers: {
-                            "content-type": "application/json",
-                            "x-api-key": apiKey,
-                            "anthropic-version": ANTHROPIC_VERSION,
-                        },
-                        body: JSON.stringify(body),
-                    });
-                    if (!response.ok) {
-                        const text = await response.text().catch((error) => {
-                            // Preserve cancellation: never turn an abort into an API error.
-                            if (signal?.aborted)
-                                return throwCancellation(signal, error);
-                            if (error?.name === "AbortError")
-                                throw error;
-                            return "";
+                execute: async ({ query }, context) => {
+                    const signal = context?.signal;
+                    try {
+                        const apiKey = await resolveApiKey(ctx, options, signal);
+                        if (!apiKey) {
+                            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: readString(options.model) ?? readEnv("WEBSEARCH_MODEL") ?? DEFAULT_MODEL,
+                            // Valid options win; an unset or invalid option falls back to env.
+                            maxUses: pickMaxUses(options.maxUses) ?? resolveMaxUses(readEnv("WEBSEARCH_MAX_USES")),
+                            thinking: pickThinking(options.thinking) ?? resolveThinking(readEnv("WEBSEARCH_THINKING")),
                         });
-                        // An abort can also arrive after the body resolves; re-check so it
-                        // is not masked as an API error.
+                        const response = await fetch(API_URL, {
+                            method: "POST",
+                            signal,
+                            headers: {
+                                "content-type": "application/json",
+                                "x-api-key": apiKey,
+                                "anthropic-version": ANTHROPIC_VERSION,
+                            },
+                            body: JSON.stringify(body),
+                        });
+                        if (!response.ok) {
+                            const text = await response.text().catch((error) => {
+                                // Preserve cancellation: never turn an abort into an API error.
+                                if (signal?.aborted)
+                                    return throwCancellation(signal, error);
+                                if (error?.name === "AbortError")
+                                    throw error;
+                                const detail = error instanceof Error ? error.message : String(error);
+                                return `[body read failed: ${detail}]`;
+                            });
+                            // An abort can also arrive after the body resolves; re-check so it
+                            // is not masked as an API error.
+                            if (signal?.aborted)
+                                throwCancellation(signal, undefined);
+                            throw new Error(`DeepSeek API error ${response.status}: ${text.slice(0, 300)}`);
+                        }
+                        const data = (await response.json());
+                        // A cancellation may arrive after the response completed.
                         if (signal?.aborted)
                             throwCancellation(signal, undefined);
-                        throw new Error(`DeepSeek API error ${response.status}: ${text.slice(0, 300)}`);
+                        const { answer, sources } = extractAnswerAndSources(data);
+                        return toResults(answer, sources);
+                    }
+                    catch (error) {
+                        // `fetch`/`json` reject with the raw signal reason; normalise any
+                        // cancellation so callers always receive an Error.
+                        if (signal?.aborted)
+                            throwCancellation(signal, error);
+                        throw error;
                     }
-                    const data = (await response.json());
-                    const { answer, sources } = extractAnswerAndSources(data);
-                    return toResults(answer, sources);
                 },
             });
             editor.default.set("deepseek");

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-websearch-deepseek",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "DeepSeek-powered web search provider for OpenCode's built-in websearch tool.",
   "type": "module",
   "license": "MIT",
@@ -44,8 +44,8 @@
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "npm run build && node --test",
+    "prepare": "node -e \"const fs=require('node:fs');if(fs.existsSync('dist/index.js'))process.exit(0);try{require.resolve('typescript')}catch{process.exit(0)};require('node:child_process').execSync('npm run build',{stdio:'inherit'})\"",
     "prepack": "npm run build",
-    "prepublishOnly": "npm run build && node --test",
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "devDependencies": {