@noirhare/dsh-web-search-tavily 0.0.1

package/cordis.patch.yml

@@ -0,0 +1,5 @@
+- insert:
+  - name: "@noirhare/dsh-web-search-tavily"
+    config:
+      apiKey: tvly-proxy-ebed5ea3-dacd-4f4b-acc4-d159f8b46270
+      url: https://tavily-proxy.noirhare.workers.dev/search

package/lib/host/index.js

@@ -0,0 +1,107 @@
+// src/host/index.ts
+import z from "@deepseek-ai/schemastery";
+
+// src/host/provider.ts
+import { WebError } from "@deepseek-ai/dsh-web";
+var TAVILY_PROVIDER_ID = "tavily";
+var TAVILY_DEFAULT_URL = "https://api.tavily.com/search";
+var USER_AGENT = "deepseek-harness/0.0.1";
+var TavilySearchProvider = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  id = TAVILY_PROVIDER_ID;
+  available() {
+    return this.options.apiKey.length > 0 && URL.canParse(this.options.url);
+  }
+  async search(request, signal) {
+    const maxResults = request.maxResults ?? this.options.maxResults;
+    let response;
+    try {
+      response = await fetch(this.options.url, {
+        method: "POST",
+        redirect: "error",
+        headers: {
+          "authorization": `Bearer ${this.options.apiKey}`,
+          "content-type": "application/json",
+          "accept": "application/json",
+          "user-agent": USER_AGENT
+        },
+        body: JSON.stringify({
+          query: request.query,
+          search_depth: this.options.searchDepth,
+          chunks_per_source: this.options.chunksPerSource,
+          max_results: maxResults,
+          include_answer: true
+        }),
+        ...signal !== void 0 ? { signal } : {}
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new WebError("Tavily search aborted", "WEB_ABORTED", { cause: error });
+      }
+      throw new WebError(`Tavily search request failed: ${String(error)}`, "WEB_PROVIDER_ERROR", { cause: error });
+    }
+    if (!response.ok) {
+      const status = response.status;
+      let message = `Tavily API error (HTTP ${status})`;
+      try {
+        const error = (await response.json()).detail?.error;
+        if (error !== void 0 && error.length > 0) message = error;
+      } catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+          throw new WebError("Tavily search aborted", "WEB_ABORTED", { cause: error });
+        }
+      }
+      throw new WebError(message, "WEB_PROVIDER_ERROR");
+    }
+    try {
+      const payload = await response.json();
+      return {
+        content: payload.answer,
+        sources: payload.results.map((r) => ({
+          url: r.url,
+          title: r.title,
+          snippet: r.content
+        })),
+        truncated: true
+      };
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new WebError("Tavily search aborted", "WEB_ABORTED", { cause: error });
+      }
+      throw new WebError(`Tavily returned an unprocessable response body: ${String(error)}`, "WEB_PROVIDER_ERROR", { cause: error });
+    }
+  }
+};
+
+// src/host/index.ts
+import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+var name = "web-search-tavily";
+var inject = ["web"];
+var Config = z.object({
+  apiKey: z.string(),
+  url: z.string(),
+  searchDepth: z.union(["basic", "advanced", "fast", "ultra-fast"]),
+  chunksPerSource: z.number(),
+  maxResults: z.number()
+});
+function apply(ctx, config) {
+  ctx.web.registerSearchProvider(
+    new TavilySearchProvider({
+      apiKey: config.apiKey ?? launchEnvironmentOf(ctx).get("TAVILY_API_KEY")?.value ?? "",
+      url: config.url ?? TAVILY_DEFAULT_URL,
+      searchDepth: config.searchDepth,
+      chunksPerSource: config.chunksPerSource,
+      maxResults: config.maxResults
+    })
+  );
+}
+export {
+  Config,
+  apply,
+  inject,
+  name
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/host/index.ts", "../../src/host/provider.ts"],
  "sourcesContent": ["import z from \"@deepseek-ai/schemastery\";\r\n\r\nimport { Context } from \"@deepseek-ai/cordis\";\r\nimport { TAVILY_DEFAULT_URL, TavilySearchProvider } from \"./provider\";\r\nimport { launchEnvironmentOf } from \"@deepseek-ai/dsh-launch-environment\";\r\n\r\nexport const name = \"web-search-tavily\";\r\nexport const inject = [\"web\"];\r\nexport interface Config {\r\n    apiKey?: string\r\n    url?: string\r\n\r\n    searchDepth?: \"basic\" | \"advanced\" | \"fast\" | \"ultra-fast\"\r\n    chunksPerSource?: number\r\n    maxResults?: number\r\n}\r\n\r\nexport const Config: z<Config> = z.object({\r\n    apiKey: z.string(),\r\n    url: z.string(),\r\n\r\n    searchDepth: z.union([\"basic\", \"advanced\", \"fast\", \"ultra-fast\"] as const),\r\n    chunksPerSource: z.number(),\r\n    maxResults: z.number(),\r\n});\r\n\r\nexport function apply(ctx: Context, config: Config): void {\r\n    ctx.web.registerSearchProvider(\r\n        new TavilySearchProvider({\r\n            apiKey: config.apiKey ?? launchEnvironmentOf(ctx).get(\"TAVILY_API_KEY\")?.value ?? \"\",\r\n            url: config.url ?? TAVILY_DEFAULT_URL,\r\n            searchDepth: config.searchDepth,\r\n            chunksPerSource: config.chunksPerSource,\r\n            maxResults: config.maxResults,\r\n        }),\r\n    );\r\n}\r\n", "import { WebError, WebSearchProvider, WebSearchRequest, WebSearchResult } from \"@deepseek-ai/dsh-web\";\r\nimport type { TavilyError, TavilySearchResponse } from \"./types\";\r\n\r\nexport const TAVILY_PROVIDER_ID = \"tavily\";\r\n\r\nexport const TAVILY_DEFAULT_URL = \"https://api.tavily.com/search\";\r\n\r\nconst USER_AGENT = \"deepseek-harness/0.0.1\";\r\n\r\nexport interface TavilySearchProviderOptions {\r\n    apiKey: string\r\n    url: string\r\n    searchDepth?: \"basic\" | \"advanced\" | \"fast\" | \"ultra-fast\"\r\n    chunksPerSource?: number\r\n    maxResults?: number\r\n}\r\n\r\nexport class TavilySearchProvider implements WebSearchProvider {\r\n    readonly id = TAVILY_PROVIDER_ID;\r\n\r\n    constructor(private readonly options: TavilySearchProviderOptions) {}\r\n\r\n    available(): boolean {\r\n        return this.options.apiKey.length > 0 && URL.canParse(this.options.url);\r\n    }\r\n\r\n    async search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult> {\r\n        const maxResults = request.maxResults ?? this.options.maxResults;\r\n        let response: Response;\r\n        try {\r\n            response = await fetch(this.options.url, {\r\n                method: \"POST\",\r\n                redirect: \"error\",\r\n                headers: {\r\n                    \"authorization\": `Bearer ${this.options.apiKey}`,\r\n                    \"content-type\": \"application/json\",\r\n                    \"accept\": \"application/json\",\r\n                    \"user-agent\": USER_AGENT,\r\n                },\r\n                body: JSON.stringify({\r\n                    query: request.query,\r\n                    search_depth: this.options.searchDepth,\r\n                    chunks_per_source: this.options.chunksPerSource,\r\n                    max_results: maxResults,\r\n                    include_answer: true,\r\n                }),\r\n                ...signal !== undefined ? { signal } : {},\r\n            });\r\n        } catch (error: unknown) {\r\n            if (error instanceof DOMException && error.name === \"AbortError\") {\r\n                throw new WebError(\"Tavily search aborted\", \"WEB_ABORTED\", { cause: error });\r\n            }\r\n            throw new WebError(`Tavily search request failed: ${String(error)}`, \"WEB_PROVIDER_ERROR\", { cause: error });\r\n        }\r\n\r\n        if (!response.ok) {\r\n            const status = response.status;\r\n            let message = `Tavily API error (HTTP ${status})`;\r\n            try {\r\n                const error = (await response.json() as TavilyError).detail?.error;\r\n                if (error !== undefined && error.length > 0) message = error;\r\n            } catch (error: unknown) {\r\n                if (error instanceof DOMException && error.name === \"AbortError\") {\r\n                    throw new WebError(\"Tavily search aborted\", \"WEB_ABORTED\", { cause: error });\r\n                }\r\n            }\r\n            throw new WebError(message, \"WEB_PROVIDER_ERROR\");\r\n        }\r\n\r\n        try {\r\n            const payload = await response.json() as TavilySearchResponse;\r\n            return {\r\n                content: payload.answer,\r\n                sources: payload.results.map((r) => ({\r\n                    url: r.url,\r\n                    title: r.title,\r\n                    snippet: r.content,\r\n                })),\r\n                truncated: true,\r\n            };\r\n        } catch (error: unknown) {\r\n            if (error instanceof DOMException && error.name === \"AbortError\") {\r\n                throw new WebError(\"Tavily search aborted\", \"WEB_ABORTED\", { cause: error });\r\n            }\r\n            throw new WebError(`Tavily returned an unprocessable response body: ${String(error)}`, \"WEB_PROVIDER_ERROR\", { cause: error });\r\n        }\r\n    }\r\n}\r\n"],
  "mappings": "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",
  "names": []
}


package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@noirhare/dsh-web-search-tavily",
+  "version": "0.0.1",
+  "license": "MIT",
+  "author": {
+    "name": "NoirHare",
+    "url": "https://github.com/NoirHare"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NoirHare/dsh-bundle.git",
+    "directory": "packages/web-search-tavily"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./lib/host/index.js",
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@deepseek-ai/dsh-launch-environment": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-web": "^0.1.1-rc.2"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "tsc -b && node build.ts",
+    "prepublish": "pnpm build"
+  }
+}