@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/coupontools/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const coupontoolsApiBaseUrl = "https://api.coupontools.com";
 export async function validateCoupontoolsCredential(input, fetcher, signal) {
     await requestCoupontoolsJson({
@@ -49,7 +49,7 @@ export async function executeCoupontoolsAction(input, fetcher) {
         }
         case "create_single_use_url": {
             if (input.input.customvalcode != null && input.input.autovalcode != null) {
-                throw providerError("invalid_input", "customvalcode and autovalcode cannot be used together", 400);
+                throw providerInputError("customvalcode and autovalcode cannot be used together");
             }
             const raw = await requestCoupontoolsJson({
                 path: "/v3/singleuse/create",
@@ -64,7 +64,7 @@ export async function executeCoupontoolsAction(input, fetcher) {
             const singleUseUrl = optionalString(raw.single_use_url)?.trim();
             const singleUseCode = optionalString(raw.single_use_code)?.trim();
             if (!singleUseUrl || !singleUseCode) {
-                throw providerError("provider_error", "Coupontools response did not include single_use_url and single_use_code", 502);
+                throw providerResponseError("Coupontools response did not include single_use_url and single_use_code");
             }
             return {
                 single_use_url: singleUseUrl,
@@ -76,7 +76,7 @@ export async function executeCoupontoolsAction(input, fetcher) {
 }
 function requireCouponArray(value) {
     if (!Array.isArray(value)) {
-        throw providerError("provider_error", "Coupontools coupon_info must be an array", 502);
+        throw providerResponseError("Coupontools coupon_info must be an array");
     }
     return value;
 }
@@ -104,13 +104,13 @@ async function requestCoupontoolsJson(input) {
 async function readCoupontoolsPayload(response) {
     const text = await response.text();
     if (!text.trim()) {
-        throw providerError("provider_error", "Coupontools returned an empty response", 502);
+        throw providerResponseError("Coupontools returned an empty response");
     }
     try {
         return JSON.parse(text);
     }
     catch {
-        throw providerError("provider_error", "Coupontools returned invalid JSON", 502);
+        throw providerResponseError("Coupontools returned invalid JSON");
     }
 }
 function hasCoupontoolsError(payload) {
@@ -125,22 +125,19 @@ function createCoupontoolsError(statusCode, payload, phase) {
         optionalString(payloadRecord?.message)?.trim() ??
         `Coupontools request failed with status ${statusCode}`;
     if (statusCode == 429) {
-        return providerError("rate_limited", message, 429);
+        return new ProviderRequestError(429, message);
     }
     if (phase == "validate" && 400 <= statusCode && statusCode < 500) {
-        return providerError("invalid_input", message, 400);
+        return providerInputError(message);
     }
     if (statusCode == 401 || statusCode == 403) {
-        return providerError("provider_error", message, statusCode);
+        return new ProviderRequestError(statusCode, message);
     }
     if (400 <= statusCode && statusCode < 500) {
-        return providerError("invalid_input", message, statusCode);
+        return new ProviderRequestError(statusCode, message);
     }
-    return providerError("provider_error", message, statusCode >= 400 ? statusCode : 502);
+    return new ProviderRequestError(statusCode >= 400 ? statusCode : 502, message);
 }
 function requireStoredClientSecret(values) {
     return requiredInputString(values?.clientSecret, "clientSecret");
 }
-function providerError(_code, message, status) {
-    return new ProviderRequestError(status, message);
-}

package/src/providers/crtsh/executors.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/crtsh/executors.js

@@ -0,0 +1,19 @@
+import { defineProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { readCrtshError } from "./runtime.js";
+import { crtshActionHandlers, crtshApiBaseUrl } from "./runtime.js";
+const service = "crtsh";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: crtshActionHandlers,
+    skipDnsValidation: true,
+    createContext(context, fetcher) {
+        return { fetcher, signal: context.signal };
+    },
+});
+export const proxy = defineProviderProxy({
+    readError: readCrtshError,
+    service,
+    baseUrl: crtshApiBaseUrl,
+    auth: { type: "none" },
+    skipDnsValidation: true,
+});

package/src/providers/crtsh/runtime.d.ts

@@ -0,0 +1,17 @@
+import type { ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export declare const crtshApiBaseUrl = "https://crt.sh";
+export interface CrtshRuntimeContext {
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}
+type CrtshActionHandler = (input: Record<string, unknown>, context: CrtshRuntimeContext) => Promise<unknown>;
+export declare const crtshActionHandlers: ProviderActionHandlers<"crtsh", CrtshActionHandler>;
+/**
+ * Map a crt.sh error onto the runtime's status conventions. crt.sh serves HTML
+ * error pages when overloaded, so surface a short excerpt instead of the page.
+ * The search endpoint needs no credentials, so an authorization failure is not
+ * something reconnecting can fix.
+ */
+export declare function readCrtshError(response: Response): Promise<ProviderRequestError>;
+export {};

package/src/providers/crtsh/runtime.js

@@ -0,0 +1,84 @@
+import { looseArray, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
+import { parseProviderJsonBodyText, providerInputError, ProviderRequestError, providerUserAgent, readProviderErrorTextBody, readProviderTextBody, requiredInputString, runProviderRequest, setSearchParams, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const crtshApiBaseUrl = "https://crt.sh";
+const defaultLimit = 100;
+export const crtshActionHandlers = {
+    async search_certificates(input, context) {
+        const domain = domainQueryParam(input.domain);
+        const limit = optionalInteger(input.limit) ?? defaultLimit;
+        const payload = await requestCrtsh({ context, domain });
+        const records = looseArray(payload);
+        const certificates = [];
+        for (const item of records) {
+            const record = optionalRecord(item);
+            if (!record)
+                continue;
+            certificates.push(normalizeCertificate(record));
+            if (certificates.length >= limit)
+                break;
+        }
+        return {
+            certificates,
+            returned: certificates.length,
+            total_matches: records.length,
+        };
+    },
+};
+/**
+ * crt.sh treats `q` as a SQL LIKE pattern where % is the wildcard. Keep the
+ * charset tight so a model-supplied URL or junk never reaches the query string.
+ */
+function domainQueryParam(value) {
+    const domain = requiredInputString(value, "domain").trim();
+    if (!/^[A-Za-z0-9%][A-Za-z0-9.\-_%]*$/.test(domain)) {
+        throw providerInputError("domain must be a domain such as example.com, optionally with % wildcards like %.example.com.");
+    }
+    return domain;
+}
+async function requestCrtsh(request) {
+    const url = new URL(crtshApiBaseUrl);
+    // Explicit ILIKE: crt.sh defaults hyphenated queries to "Single" matching,
+    // which disables % wildcards (see certwatch_db web_apis.fnc).
+    setSearchParams(url, { q: request.domain, output: "json", match: "ILIKE" });
+    return runProviderRequest({ label: "crt.sh", signal: request.context.signal }, async (signal) => {
+        const response = await request.context.fetcher(url, {
+            headers: {
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+            },
+            signal,
+        });
+        if (!response.ok) {
+            throw await readCrtshError(response);
+        }
+        return parseProviderJsonBodyText(await readProviderTextBody(response, "crt.sh response"), {
+            emptyBody: [],
+            invalidJsonMessage: "crt.sh returned malformed JSON",
+        });
+    });
+}
+function normalizeCertificate(record) {
+    return {
+        ...record,
+        id: optionalInteger(record.id) ?? 0,
+        issuer_ca_id: optionalInteger(record.issuer_ca_id) ?? 0,
+        issuer_name: optionalString(record.issuer_name) ?? "",
+        common_name: optionalString(record.common_name) ?? "",
+        name_value: optionalString(record.name_value) ?? "",
+        not_before: optionalString(record.not_before) ?? "",
+        not_after: optionalString(record.not_after) ?? "",
+        serial_number: optionalString(record.serial_number) ?? "",
+    };
+}
+/**
+ * Map a crt.sh error onto the runtime's status conventions. crt.sh serves HTML
+ * error pages when overloaded, so surface a short excerpt instead of the page.
+ * The search endpoint needs no credentials, so an authorization failure is not
+ * something reconnecting can fix.
+ */
+export async function readCrtshError(response) {
+    const text = (await readProviderErrorTextBody(response, "crt.sh error response")).trim();
+    const message = text.slice(0, 200) || `crt.sh request failed with HTTP ${response.status}`;
+    const status = response.status;
+    return new ProviderRequestError(status, message, withRetryAfterSeconds(response, {}), status === 429 ? "rate_limited" : "provider_error");
+}

package/src/providers/deepseek/executors.d.ts

@@ -1,9 +1,4 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
-import type { ProviderActionHandlers } from "../provider-runtime.ts";
-import type { ApiKeyProviderContext } from "../provider-runtime.ts";
-type DeepseekActionHandler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
-export declare const deepseekActionHandlers: ProviderActionHandlers<"deepseek", DeepseekActionHandler>;
 export declare const executors: ProviderExecutors;
 export declare const credentialValidators: CredentialValidators;
 export declare const proxy: ProviderProxyExecutor;
-export {};

package/src/providers/deepseek/executors.js

@@ -1,9 +1,18 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerUserAgent, runProviderRequest, isAbortLikeError, providerInputError, } from "../provider-runtime.js";
 const service = "deepseek";
 const deepseekApiBaseUrl = "https://api.deepseek.com";
 const deepseekAnthropicApiBaseUrl = "https://api.deepseek.com/anthropic";
-export const deepseekActionHandlers = {
+const handlers = {
+    search(input, context) {
+        return deepseekRequest(context, { path: "/v1/tools/search", method: "POST", body: input });
+    },
+    fetch(input, context) {
+        const url = URL.parse(String(input.url));
+        if (!url || !["http:", "https:"].includes(url.protocol) || !url.hostname || url.username || url.password)
+            throw providerInputError("url must be an HTTP or HTTPS URL with a host and no username or password");
+        return deepseekRequest(context, { path: "/v1/tools/fetch", method: "POST", body: input });
+    },
     list_models(_input, context) {
         return deepseekRequest(context, { path: "/models" });
     },
@@ -12,7 +21,12 @@ export const deepseekActionHandlers = {
     },
     create_chat_completion(input, context) {
         assertStreamingDisabled(input);
-        return deepseekRequest(context, { path: "/chat/completions", method: "POST", body: compactObject(input) });
+        return deepseekRequest(context, {
+            path: "/chat/completions",
+            method: "POST",
+            body: compactObject(input),
+            timeoutMs: 0,
+        });
     },
     create_anthropic_message(input, context) {
         assertStreamingDisabled(input);
@@ -22,14 +36,15 @@ export const deepseekActionHandlers = {
             method: "POST",
             body: compactObject(input),
             anthropic: true,
+            timeoutMs: 0,
         });
     },
 };
-export const executors = defineApiKeyProviderExecutors(service, deepseekActionHandlers);
+export const executors = defineApiKeyProviderExecutors(service, handlers);
 export const credentialValidators = {
     async apiKey(input, { fetcher, signal }) {
         const context = { apiKey: input.apiKey, fetcher, signal };
-        const payload = (await deepseekRequest(context, { path: "/models", mode: "validate" }));
+        const payload = (await deepseekRequest(context, { path: "/models" }));
         return {
             profile: {
                 displayName: "DeepSeek API Key",
@@ -45,19 +60,23 @@ export const credentialValidators = {
     },
 };
 async function deepseekRequest(context, request) {
-    const response = await context.fetcher(`${request.baseUrl ?? deepseekApiBaseUrl}${request.path}`, {
-        method: request.method ?? "GET",
-        headers: request.anthropic ? deepseekAnthropicHeaders(context.apiKey) : deepseekHeaders(context.apiKey),
-        body: request.body === undefined ? undefined : JSON.stringify(request.body),
-        signal: context.signal,
+    return runProviderRequest({ label: "DeepSeek", signal: context.signal, timeoutMs: request.timeoutMs }, async (signal) => {
+        const response = await context.fetcher(`${request.baseUrl ?? deepseekApiBaseUrl}${request.path}`, {
+            method: request.method ?? "GET",
+            headers: request.anthropic ? deepseekAnthropicHeaders(context.apiKey) : deepseekHeaders(context.apiKey),
+            body: request.body === undefined ? undefined : JSON.stringify(request.body),
+            signal,
+        });
+        await assertDeepseekResponse(response);
+        try {
+            return await response.json();
+        }
+        catch (error) {
+            if (isAbortLikeError(error))
+                throw error;
+            throw new ProviderRequestError(502, "deepseek returned malformed JSON");
+        }
     });
-    await assertDeepseekResponse(response, request.mode ?? "execute");
-    try {
-        return await response.json();
-    }
-    catch {
-        throw new ProviderRequestError(502, "deepseek returned malformed JSON");
-    }
 }
 function deepseekHeaders(apiKey) {
     return {
@@ -78,7 +97,7 @@ function assertStreamingDisabled(input) {
         throw new ProviderRequestError(400, "stream=true is not supported by connector actions");
     }
 }
-async function assertDeepseekResponse(response, mode) {
+async function assertDeepseekResponse(response) {
     if (response.ok) {
         return;
     }
@@ -86,16 +105,10 @@ async function assertDeepseekResponse(response, mode) {
     if (response.status === 429) {
         throw new ProviderRequestError(429, error.message, error);
     }
-    if (mode === "validate" && (response.status === 401 || response.status === 403)) {
-        throw new ProviderRequestError(400, error.message, error);
-    }
-    if (response.status === 401 || response.status === 403) {
-        throw new ProviderRequestError(response.status, error.message, error);
-    }
     if (response.status === 400 || response.status === 422) {
         throw new ProviderRequestError(400, error.message, error);
     }
-    throw new ProviderRequestError(response.status || 500, error.message, error);
+    throw new ProviderRequestError(response.status || 500, error.message, error, "provider_error");
 }
 async function readDeepseekError(response) {
     const raw = await response.text().catch(() => "");

package/src/providers/defillama/actions.d.ts

@@ -0,0 +1,24 @@
+import type { ActionDefinition, JsonSchema } from "../../core/types.ts";
+export interface DefillamaRoute {
+    path: string;
+    parameters: Array<{
+        name: string;
+        in: string;
+    }>;
+    free: {
+        baseUrl: string;
+        path: string;
+    } | null;
+    wrap: boolean;
+}
+export interface DefillamaDefinition {
+    name: string;
+    description: string;
+    route: DefillamaRoute;
+    inputSchema: JsonSchema;
+    outputSchema: JsonSchema;
+}
+declare const definitions: DefillamaDefinition[];
+export declare const defillamaRoutes: Map<string, (typeof definitions)[number]["route"]>;
+export declare const defillamaActions: ActionDefinition[];
+export {};

package/src/providers/defillama/actions.js

@@ -0,0 +1,24 @@
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { dimensionsDefinitions } from "./dimensions-definitions.js";
+import { ecosystemDefinitions } from "./ecosystem-definitions.js";
+import { equitiesDefinitions } from "./equities-definitions.js";
+import { marketsDefinitions } from "./markets-definitions.js";
+import { tvlDefinitions } from "./tvl-definitions.js";
+import { yieldsDefinitions } from "./yields-definitions.js";
+const definitions = [
+    ...tvlDefinitions,
+    ...ecosystemDefinitions,
+    ...dimensionsDefinitions,
+    ...marketsDefinitions,
+    ...yieldsDefinitions,
+    ...equitiesDefinitions,
+];
+export const defillamaRoutes = new Map(definitions.map((value) => [value.name, value.route]));
+export const defillamaActions = definitions.map((value) => defineProviderAction("defillama", {
+    name: value.name,
+    description: value.description,
+    operationType: "read",
+    requiredScopes: [],
+    inputSchema: value.inputSchema,
+    outputSchema: value.outputSchema,
+}));

package/src/providers/defillama/dimensions-definitions.d.ts

@@ -0,0 +1,2 @@
+import type { DefillamaDefinition } from "./actions.ts";
+export declare const dimensionsDefinitions: DefillamaDefinition[];