@oomol-lab/open-connector 1.9.1 → 1.9.2

package/src/providers/search1api/executors.js

@@ -0,0 +1,72 @@
+import { optionalString } from "../../core/cast.js";
+import { storeResponseInTransit } from "../../core/request.js";
+import { runProviderRequest, ProviderRequestError, providerResponseError, defineBearerProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { search1apiActions } from "./actions.js";
+import { readSearch1apiJson, requestSearch1api, search1apiBaseUrl } from "./runtime.js";
+async function execute(actionName, values, context) {
+    const { accessToken: token, fetcher, transitFiles } = context;
+    const data = values;
+    if (actionName === "screenshot") {
+        if (!transitFiles)
+            throw new ProviderRequestError(503, "Search1API screenshots require configured file transit and execution identity", undefined, "provider_error");
+        return runProviderRequest({ label: "Search1API screenshot", signal: context.signal, timeoutMs: 60000 }, async (signal) => {
+            const response = await fetcher(`${search1apiBaseUrl}/screenshot`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${token}`,
+                    "content-type": "application/json",
+                    accept: "image/png, image/jpeg, image/webp",
+                },
+                body: JSON.stringify(data),
+                signal,
+            });
+            if (!response.ok)
+                await readSearch1apiJson(response);
+            const mimeType = response.headers.get("content-type")?.split(";")[0]?.trim();
+            if (!mimeType || !["image/png", "image/jpeg", "image/webp"].includes(mimeType) || !response.body) {
+                await response.body?.cancel();
+                throw providerResponseError("Search1API returned an invalid screenshot response");
+            }
+            const extension = mimeType.slice("image/".length);
+            const result = await storeResponseInTransit(response, transitFiles, {
+                name: `search1api-screenshot.${extension}`,
+                mimeType,
+                fieldName: "Search1API screenshot",
+                createError: providerResponseError,
+                signal,
+            });
+            return {
+                url: result.downloadUrl,
+                mimeType,
+                requestId: response.headers.get("x-request-id"),
+            };
+        });
+    }
+    const body = await requestSearch1api(token, actionName, data, fetcher, context.signal);
+    if (actionName === "deepcrawl")
+        if (!optionalString(body.taskId))
+            throw providerResponseError("Search1API task ID is missing");
+    if (actionName === "get_deepcrawl")
+        if (!optionalString(body.status))
+            throw providerResponseError("Search1API task status is missing");
+    return body;
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await requestSearch1api(input.apiKey, "usage", {}, fetcher, signal);
+        return {
+            profile: { displayName: "Search1API API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: search1apiBaseUrl },
+        };
+    },
+};
+export const executors = defineBearerProviderExecutors("search1api", Object.fromEntries(search1apiActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "search1api",
+    baseUrl: search1apiBaseUrl,
+    auth: { type: "bearer" },
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});

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

@@ -0,0 +1,3 @@
+export declare const search1apiBaseUrl = "https://api.search1api.com";
+export declare function readSearch1apiJson(response: Response, crawlBatch?: boolean): Promise<Record<string, unknown>>;
+export declare function requestSearch1api(token: string, name: string, input: Record<string, unknown>, fetcher: typeof fetch, parentSignal?: AbortSignal): Promise<Record<string, unknown>>;

package/src/providers/search1api/runtime.js

@@ -0,0 +1,44 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { requiredResponseRecord, isAbortLikeError, runProviderRequest, ProviderRequestError, providerResponseError, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const search1apiBaseUrl = "https://api.search1api.com";
+export async function readSearch1apiJson(response, crawlBatch = false) {
+    const value = await response.json().catch((error) => {
+        if (isAbortLikeError(error))
+            throw error;
+        return undefined;
+    });
+    const body = optionalRecord(value);
+    if (!response.ok || body?.ok === false) {
+        const detail = optionalString(body?.message) ?? optionalString(body?.detail) ?? optionalString(body?.error_description);
+        const code = optionalString(body?.error) ?? optionalString(body?.title);
+        throw new ProviderRequestError(response.ok ? 502 : response.status, `Search1API request failed: ${[code, detail].filter(Boolean).join(": ") || `HTTP ${response.status}`}`, withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    }
+    if (crawlBatch) {
+        if (!Array.isArray(value))
+            throw providerResponseError("Search1API batch crawl response must be an array");
+        return { results: value };
+    }
+    return requiredResponseRecord(value, "Search1API response");
+}
+export function requestSearch1api(token, name, input, fetcher, parentSignal) {
+    return runProviderRequest({ label: "Search1API", signal: parentSignal, timeoutMs: name === "ask" ? 45000 : undefined }, async (signal) => {
+        const batch = name.endsWith("_batch");
+        const action = batch ? name.slice(0, -6) : name;
+        const path = action === "get_deepcrawl" ? `/deepcrawl/status/${encodeURIComponent(String(input.taskId))}` : `/${action}`;
+        const url = new URL(path, search1apiBaseUrl);
+        const method = ["health", "usage", "get_deepcrawl"].includes(action) ? "GET" : "POST";
+        if (action === "usage" && input.period !== undefined)
+            url.searchParams.set("period", String(input.period));
+        const response = await fetcher(url, {
+            method,
+            headers: {
+                accept: "application/json",
+                "content-type": "application/json",
+                ...(action === "health" ? {} : { authorization: `Bearer ${token}` }),
+            },
+            body: method === "POST" ? JSON.stringify(batch ? input.requests : input) : undefined,
+            signal,
+        });
+        return readSearch1apiJson(response, name === "crawl_batch");
+    });
+}

package/src/providers/search1api/schemas.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const search1apiInputs: Record<string, JsonSchema>;
+export declare const search1apiOutputs: Record<string, JsonSchema>;