@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/finlight/executors.js

@@ -0,0 +1,120 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { readProviderTextBody, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, isAbortLikeError, } from "../provider-runtime.js";
+import { finlightActions } from "./actions.js";
+const baseUrl = "https://api.finlight.me/v2";
+function requireSources(value) {
+    if (!Array.isArray(value))
+        throw new ProviderRequestError(502, "Finlight returned an invalid sources list", undefined, "provider_error");
+    return value;
+}
+function errorMessage(value) {
+    const message = optionalRawString(value);
+    if (message)
+        return message;
+    if (Array.isArray(value))
+        return value.map(errorMessage).filter(Boolean).join("; ") || undefined;
+    const object = optionalRecord(value);
+    if (!object)
+        return undefined;
+    const constraints = optionalRecord(object.constraints);
+    if (constraints)
+        return errorMessage(Object.values(constraints));
+    return errorMessage(Object.values(object));
+}
+async function request(route, apiKey, fetcher, body, validating = false, parentSignal) {
+    return runProviderRequest({ signal: parentSignal, label: "Finlight" }, async (signal) => {
+        const response = await fetcher(`${baseUrl}${route}`, {
+            method: body === undefined ? "GET" : "POST",
+            headers: {
+                "X-API-KEY": apiKey,
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body,
+            signal,
+        });
+        let payload;
+        try {
+            payload = await JSON.parse(await readProviderTextBody(response, "finlight response", undefined, signal));
+        }
+        catch (error) {
+            if (error instanceof ProviderRequestError || isAbortLikeError(error))
+                throw error;
+            if (response.ok)
+                throw new ProviderRequestError(502, "Finlight returned invalid JSON", undefined, "provider_error");
+        }
+        if (!response.ok) {
+            const result = optionalRecord(payload);
+            const message = (errorMessage(result?.message) ||
+                errorMessage(result?.errors) ||
+                optionalRawString(result?.error) ||
+                `Finlight request failed with HTTP ${response.status}`).replaceAll(apiKey, "[REDACTED]");
+            const invalidKey = response.status === 401 && result?.statusCode === 401 && result.message === "Unauthorized";
+            throw new ProviderRequestError(invalidKey && validating ? 400 : response.status, message, undefined, invalidKey
+                ? validating
+                    ? "invalid_input"
+                    : "authorization_failed"
+                : response.status === 429
+                    ? "rate_limited"
+                    : "provider_error");
+        }
+        return payload;
+    });
+}
+export const executors = defineApiKeyProviderExecutors("finlight", mapProviderActionHandlers("finlight", finlightActions, (action) => async (input, context) => {
+    const apiKey = context.apiKey;
+    const fetcher = context.fetcher;
+    if (action.name === "list_sources") {
+        return {
+            sources: requireSources(await request("/sources", apiKey, fetcher, undefined, undefined, context.signal)),
+        };
+    }
+    let result;
+    if (action.name === "search_articles") {
+        result = await request("/articles", apiKey, fetcher, JSON.stringify(input), undefined, context.signal);
+    }
+    else {
+        const query = new URLSearchParams();
+        for (const [key, value] of Object.entries(input)) {
+            if (value !== undefined)
+                query.set(key, String(value));
+        }
+        result = await request(`/articles/by-link?${query}`, apiKey, fetcher, undefined, undefined, context.signal);
+    }
+    const envelope = requiredResponseRecord(result, "Finlight response");
+    if (action.name === "search_articles") {
+        if (!Array.isArray(envelope.articles))
+            throw new ProviderRequestError(502, "Finlight response is missing articles", undefined, "provider_error");
+    }
+    else {
+        requiredResponseRecord(envelope.article, "Finlight article");
+    }
+    return envelope;
+}), { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        const result = await request("/sources", requiredInputString(input.apiKey, "API Key"), fetcher, undefined, true);
+        requireSources(result);
+        return {
+            profile: { displayName: "Finlight API Key" },
+            grantedScopes: [],
+            metadata: { validationEndpoint: "/v2/sources" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "finlight",
+    baseUrl,
+    auth: { type: "api_key_header", name: "X-API-KEY" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [key, value] of Object.entries({
+            accept: "application/json",
+            "content-type": "application/json",
+            "user-agent": providerUserAgent,
+        }))
+            if (!headers.has(key))
+                headers.set(key, value);
+    },
+});

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

@@ -1,7 +1,11 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
-import type { ApiKeyProviderContext } from "../provider-runtime.ts";
-type FirecrawlActionContext = ApiKeyProviderContext;
+interface FirecrawlActionContext {
+    apiKey: string;
+    apiBaseUrl: string;
+    fetcher: typeof fetch;
+    signal?: AbortSignal;
+}
 type FirecrawlActionHandler = (input: Record<string, unknown>, context: FirecrawlActionContext) => Promise<unknown>;
 export declare const firecrawlActionHandlers: ProviderActionHandlers<"firecrawl", FirecrawlActionHandler>;
 export declare const executors: ProviderExecutors;

package/src/providers/firecrawl/executors.js

@@ -1,7 +1,8 @@
 import { compactObject, optionalNumber, optionalRecord, optionalString, pickOptionalBoolean } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed } from "../../core/request.js";
+import { createProviderFetch, defineProviderExecutors, defineProviderProxy, providerInputError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, } from "../provider-runtime.js";
 const service = "firecrawl";
-const firecrawlApiBaseUrl = "https://api.firecrawl.dev";
+const defaultFirecrawlApiBaseUrl = "https://api.firecrawl.dev";
 const firecrawlScrapeOptionAliasKeys = [
     "scrapeOptions_actions",
     "scrapeOptions_formats",
@@ -56,18 +57,39 @@ export const firecrawlActionHandlers = {
     token_usage_get: firecrawlGetAction(() => "/v2/team/token-usage"),
     token_usage_get_historical: firecrawlGetAction(() => "/v2/team/token-usage/historical", buildHistoricalUsageQuery),
 };
-export const executors = defineApiKeyProviderExecutors(service, firecrawlActionHandlers);
+export const executors = defineProviderExecutors({
+    service,
+    handlers: firecrawlActionHandlers,
+    async createContext(context, fetcher) {
+        const credential = await requireApiKeyCredential(context, service);
+        return {
+            apiKey: credential.apiKey,
+            apiBaseUrl: normalizeFirecrawlApiBaseUrl(credential.values.baseUrl),
+            fetcher,
+            signal: context.signal,
+        };
+    },
+    allowPrivateNetwork: isPrivateNetworkAccessAllowed,
+});
 export const proxy = defineProviderProxy({
     service,
-    baseUrl: firecrawlApiBaseUrl,
+    baseUrl: async (context) => {
+        const credential = await requireApiKeyCredential(context, service);
+        return normalizeFirecrawlApiBaseUrl(credential.values.baseUrl);
+    },
     auth: { type: "api_key_authorization", prefix: "Bearer " },
-    skipDnsValidation: true,
+    allowPrivateNetwork: isPrivateNetworkAccessAllowed,
 });
 export const credentialValidators = {
     async apiKey(input, { fetcher, signal }) {
+        const apiBaseUrl = normalizeFirecrawlApiBaseUrl(input.values.baseUrl);
         const payload = optionalRecord(await firecrawlRequest({
             apiKey: input.apiKey,
-            fetcher,
+            apiBaseUrl,
+            // Re-guard the shared validator fetcher with the private-network
+            // opt-in so a self-hosted instance on a private network validates
+            // when the deployment allows it.
+            fetcher: createProviderFetch({ fetch: fetcher, allowPrivateNetwork: isPrivateNetworkAccessAllowed }),
             signal,
             path: "/v2/team/credit-usage",
             phase: "validate",
@@ -79,7 +101,7 @@ export const credentialValidators = {
             },
             grantedScopes: [],
             metadata: compactObject({
-                apiBaseUrl: firecrawlApiBaseUrl,
+                apiBaseUrl,
                 validationEndpoint: "/v2/team/credit-usage",
                 teamCreditUsage: optionalRecord(payload?.data),
                 success: typeof payload?.success === "boolean" ? payload.success : undefined,
@@ -90,6 +112,7 @@ export const credentialValidators = {
 function firecrawlPostAction(path, buildBody) {
     return (input, context) => firecrawlRequest({
         apiKey: context.apiKey,
+        apiBaseUrl: context.apiBaseUrl,
         fetcher: context.fetcher,
         signal: context.signal,
         method: "POST",
@@ -101,6 +124,7 @@ function firecrawlPostAction(path, buildBody) {
 function firecrawlGetAction(buildPath, buildQuery) {
     return (input, context) => firecrawlRequest({
         apiKey: context.apiKey,
+        apiBaseUrl: context.apiBaseUrl,
         fetcher: context.fetcher,
         signal: context.signal,
         path: buildPath(input),
@@ -111,6 +135,7 @@ function firecrawlGetAction(buildPath, buildQuery) {
 function firecrawlDeleteAction(buildPath) {
     return (input, context) => firecrawlRequest({
         apiKey: context.apiKey,
+        apiBaseUrl: context.apiBaseUrl,
         fetcher: context.fetcher,
         signal: context.signal,
         method: "DELETE",
@@ -166,8 +191,34 @@ function buildScrapeOptionsFromInput(input) {
     });
     return Object.keys(flattened).length > 0 ? flattened : undefined;
 }
+/**
+ * Resolves the Firecrawl API base URL for a connection. Empty input targets
+ * the Firecrawl cloud API; otherwise the self-hosted instance URL is
+ * validated, embedded credentials are rejected, and query, hash, and trailing
+ * slashes are removed while any reverse-proxy path prefix is kept.
+ * Private/overlay targets are only accepted when the deployment opts in
+ * through `OOMOL_CONNECT_ALLOW_PRIVATE_NETWORK`.
+ */
+function normalizeFirecrawlApiBaseUrl(value) {
+    const instanceUrl = optionalString(value);
+    if (!instanceUrl) {
+        return defaultFirecrawlApiBaseUrl;
+    }
+    const url = assertPublicHttpUrl(instanceUrl, {
+        fieldName: "baseUrl",
+        createError: providerInputError,
+        allowPrivateNetwork: isPrivateNetworkAccessAllowed(),
+    });
+    if (url.username || url.password) {
+        throw providerInputError("baseUrl must not include credentials");
+    }
+    url.hash = "";
+    url.search = "";
+    url.pathname = url.pathname.replace(/\/+$/u, "");
+    return url.toString().replace(/\/$/u, "");
+}
 async function firecrawlRequest(input) {
-    const url = new URL(input.path, firecrawlApiBaseUrl);
+    const url = new URL(`${input.apiBaseUrl}${input.path}`);
     for (const [key, value] of Object.entries(input.query ?? {})) {
         if (value == null) {
             continue;
@@ -229,7 +280,7 @@ function createFirecrawlError(status, payload, phase) {
         return new ProviderRequestError(status, message, payload);
     }
     if (status === 401 || status === 403) {
-        return new ProviderRequestError(phase === "validate" ? 400 : 401, message, payload);
+        return new ProviderRequestError(phase === "validate" ? 400 : status, message, payload, phase === "validate" ? "invalid_input" : "provider_error");
     }
     if (status === 429) {
         return new ProviderRequestError(429, message, payload);

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

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const flotiqActions: ActionDefinition[];

package/src/providers/flotiq/actions.js

@@ -0,0 +1,114 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const service = "flotiq";
+const contentType = s.nonEmptyString("The content type API name, such as blogposts.");
+const id = s.nonEmptyString("The content object ID.");
+const hydrate = s.integer("Relation hydration depth: 0, 1 or 2.", { minimum: 0, maximum: 2 });
+const preview = s.boolean("Include draft and archived content using X-MODE: preview; defaults to false.");
+const objectOutput = s.object("The returned content object.", {
+    object: s.looseObject("The content object's schema-defined fields and Flotiq metadata."),
+}, {
+    optional: [],
+});
+const content = s.looseObject("Content fields matching the content type schema, including optional id and relation references. Maximum object size is 1 MB.");
+export const flotiqActions = [
+    defineProviderAction(service, {
+        name: "get_content_type",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get a Flotiq content type definition to discover its fields before reading or writing objects.",
+        inputSchema: s.object("Content type lookup parameters.", {
+            contentType,
+            resolveRef: s.boolean("Resolve schema references; defaults to false."),
+            strictSchema: s.boolean("Use the OpenAPI-compatible schema property when resolveRef is true."),
+        }, {
+            optional: ["resolveRef", "strictSchema"],
+        }),
+        outputSchema: s.object("The content type definition.", {
+            contentType: s.looseObject("The complete content type definition and schema."),
+        }, {
+            optional: [],
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "list_content_objects",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List one page of Flotiq content objects with filtering, sorting, relation hydration and optional draft preview.",
+        inputSchema: s.object("Content object listing parameters.", {
+            contentType,
+            page: s.integer("The 1-based page number; defaults to 1.", { minimum: 1 }),
+            limit: s.integer("Objects per page; defaults to 20, maximum 1000.", {
+                minimum: 1,
+                maximum: 1000,
+            }),
+            order_by: s.nonEmptyString("The schema field to sort by, such as internal.createdAt."),
+            order_direction: s.stringEnum("Sort direction; defaults to asc.", ["asc", "desc"]),
+            empty_first: s.boolean("Place empty values first; defaults to false."),
+            filters: s.looseObject("Flotiq filter conditions keyed by field, such as {title: {type: 'equals', filter: 'Hello'}}. Encoded as JSON by the connector."),
+            hydrate,
+            preview,
+        }, {
+            optional: ["page", "limit", "order_by", "order_direction", "empty_first", "filters", "hydrate", "preview"],
+        }),
+        outputSchema: s.looseObject("One page of content objects and upstream pagination metadata.", {
+            data: s.array("The content objects on this page.", s.looseObject("A content object with user-defined fields.")),
+            total_count: s.integer("Total matching objects."),
+            total_pages: s.integer("Total available pages."),
+            current_page: s.integer("The returned 1-based page number."),
+            count: s.integer("The number of objects on this page."),
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "get_content_object",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get a Flotiq content object by ID with optional relation hydration and draft preview.",
+        inputSchema: s.object("Content object lookup parameters.", { contentType, id, hydrate, preview }, {
+            optional: ["hydrate", "preview"],
+        }),
+        outputSchema: objectOutput,
+    }),
+    defineProviderAction(service, {
+        name: "create_content_object",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Create a Flotiq content object using fields from its content type schema. Types with Draft & Public enabled create drafts.",
+        inputSchema: s.object("Content object creation parameters.", { contentType, content }, {
+            optional: [],
+        }),
+        outputSchema: objectOutput,
+    }),
+    defineProviderAction(service, {
+        name: "update_content_object",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Update a Flotiq content object. PATCH changes supplied fields; PUT replaces object data and requires all schema-required fields.",
+        inputSchema: s.object("Content object update parameters.", {
+            contentType,
+            id,
+            content,
+            method: s.stringEnum("Update method; defaults to PATCH. PUT requires the complete object data.", [
+                "PATCH",
+                "PUT",
+            ]),
+        }, {
+            optional: ["method"],
+        }),
+        outputSchema: objectOutput,
+    }),
+    defineProviderAction(service, {
+        name: "delete_content_object",
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Delete one Flotiq content object by ID. Flotiq can reject deletion when other objects reference it.",
+        inputSchema: s.object("Content object deletion parameters.", { contentType, id }, {
+            optional: [],
+        }),
+        outputSchema: s.object("The confirmed deletion result.", {
+            deleted: s.boolean("Whether Flotiq accepted the deletion."),
+        }, {
+            optional: [],
+        }),
+    }),
+];

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

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

package/src/providers/flotiq/executors.js

@@ -0,0 +1,135 @@
+import { optionalRecord, optionalRawString, requiredRawString } from "../../core/cast.js";
+import { readProviderTextBody, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, providerInputError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { flotiqActions } from "./actions.js";
+const baseUrl = "https://api.flotiq.com";
+function encodePathSegment(value) {
+    if (value === "." || value === "..") {
+        throw new ProviderRequestError(400, "Flotiq path identifiers cannot be dot segments", undefined, "invalid_input");
+    }
+    return encodeURIComponent(value);
+}
+async function requestFlotiq(apiKey, fetcher, pathname, method = "GET", query = {}, body, preview = false, parentSignal) {
+    const url = new URL(pathname, baseUrl);
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined)
+            url.searchParams.set(key, String(value));
+    }
+    return runProviderRequest({ signal: parentSignal, label: "Flotiq" }, async (signal) => {
+        const headers = new Headers({
+            accept: "application/json",
+            "X-AUTH-TOKEN": apiKey,
+            "user-agent": providerUserAgent,
+        });
+        if (body !== undefined)
+            headers.set("content-type", "application/json");
+        if (preview)
+            headers.set("X-MODE", "preview");
+        const response = await fetcher(url, {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal,
+        });
+        const text = await readProviderTextBody(response, "flotiq response", undefined, signal);
+        let payload;
+        try {
+            payload = text ? JSON.parse(text) : undefined;
+        }
+        catch {
+            if (response.ok)
+                throw new ProviderRequestError(502, "Flotiq returned invalid JSON", undefined, "provider_error");
+        }
+        if (!response.ok) {
+            const object = optionalRecord(payload);
+            const message = optionalRawString(object?.message) ??
+                flotiqValidationMessage(object) ??
+                `Flotiq request failed (${response.status})`;
+            throw new ProviderRequestError(response.status, message, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        if (method === "DELETE" && response.status === 204)
+            return {};
+        return requiredResponseRecord(payload, "Flotiq response");
+    });
+}
+function flotiqValidationMessage(payload) {
+    if (!payload)
+        return undefined;
+    const messages = [];
+    for (const [field, errors] of Object.entries(payload)) {
+        if (!Array.isArray(errors))
+            continue;
+        for (const error of errors) {
+            const message = optionalRawString(error);
+            if (message)
+                messages.push(`${field}: ${message}`);
+        }
+    }
+    return messages.length ? messages.join("; ") : undefined;
+}
+export const executors = defineApiKeyProviderExecutors("flotiq", mapProviderActionHandlers("flotiq", flotiqActions, (action) => async (input, context) => {
+    const data = input;
+    const name = encodePathSegment(requiredRawString(data.contentType, "contentType", providerInputError));
+    const apiKey = context.apiKey;
+    const fetcher = context.fetcher;
+    if (action.name === "get_content_type") {
+        const contentType = await requestFlotiq(apiKey, fetcher, `/api/v1/internal/contenttype/${name}`, "GET", {
+            resolveRef: data.resolveRef,
+            strictSchema: data.strictSchema,
+        }, undefined, undefined, context.signal);
+        return { contentType };
+    }
+    const collection = `/api/v1/content/${name}`;
+    if (action.name === "list_content_objects") {
+        return requestFlotiq(apiKey, fetcher, collection, "GET", {
+            page: data.page,
+            limit: data.limit,
+            order_by: data.order_by,
+            order_direction: data.order_direction,
+            empty_first: data.empty_first,
+            filters: data.filters === undefined ? undefined : JSON.stringify(data.filters),
+            hydrate: data.hydrate,
+        }, undefined, data.preview === true, context.signal);
+    }
+    if (action.name === "create_content_object") {
+        return {
+            object: await requestFlotiq(apiKey, fetcher, collection, "POST", {}, data.content, undefined, context.signal),
+        };
+    }
+    const objectPath = `${collection}/${encodePathSegment(requiredRawString(data.id, "id", providerInputError))}`;
+    if (action.name === "delete_content_object") {
+        await requestFlotiq(apiKey, fetcher, objectPath, "DELETE", undefined, undefined, undefined, context.signal);
+        return { deleted: true };
+    }
+    if (action.name === "update_content_object") {
+        return {
+            object: await requestFlotiq(apiKey, fetcher, objectPath, optionalRawString(data.method) ?? "PATCH", {}, data.content, undefined, context.signal),
+        };
+    }
+    return {
+        object: await requestFlotiq(apiKey, fetcher, objectPath, "GET", { hydrate: data.hydrate }, undefined, data.preview === true, context.signal),
+    };
+}), { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        await requestFlotiq(requiredInputString(input.apiKey, "API Key"), fetcher, "/api/auth-context");
+        return {
+            profile: { displayName: "Flotiq API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationEndpoint: "/api/auth-context" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "flotiq",
+    baseUrl,
+    auth: { type: "api_key_header", name: "X-AUTH-TOKEN" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [key, value] of Object.entries({
+            accept: "application/json",
+            "user-agent": providerUserAgent,
+        }))
+            if (!headers.has(key))
+                headers.set(key, value);
+    },
+});

package/src/providers/framejet/runtime.js

@@ -1,6 +1,6 @@
 import { createHmac } from "node:crypto";
 import { optionalIntegerOrNull, optionalRecord, optionalString } from "../../core/cast.js";
-import { readBoundedResponseBytes } from "../../core/request.js";
+import { storeResponseInTransit } from "../../core/request.js";
 import { providerInputError, providerResponseError, providerUserAgent, readProviderErrorTextBody, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
 export const framejetApiBaseUrl = "https://framejet.dev";
 // A capture may wait for slow pages, page steps and goal mode, so it gets more than the default budget.
@@ -61,14 +61,15 @@ async function takeFramejetScreenshot(input, context) {
         if (!response.ok) {
             throw await readFramejetError(response);
         }
-        const bytes = await readBoundedResponseBytes(response, {
-            maxBytes: transitFiles.maxBytes,
+        const mimeType = response.headers.get("content-type")?.split(";")[0]?.trim() || "image/png";
+        const name = mimeType === "image/jpeg" ? "framejet-screenshot.jpg" : "framejet-screenshot.png";
+        const upload = await storeResponseInTransit(response, transitFiles, {
+            name,
+            mimeType,
             fieldName: "Framejet screenshot",
             createError: (message) => new ProviderRequestError(413, message),
+            signal,
         });
-        const mimeType = response.headers.get("content-type")?.split(";")[0]?.trim() || "image/png";
-        const name = mimeType === "image/jpeg" ? "framejet-screenshot.jpg" : "framejet-screenshot.png";
-        const upload = await transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
         return {
             file: {
                 fileId: upload.fileId,

package/src/providers/freeastroapi/constants.d.ts

@@ -0,0 +1,8 @@
+interface NumerologyProfiles {
+    pythagorean: readonly string[];
+    chaldean: readonly string[];
+    kabbalah: readonly string[];
+    ank_jyotish: readonly string[];
+}
+export declare const numerologyProfiles: NumerologyProfiles;
+export {};

package/src/providers/freeastroapi/constants.js

@@ -0,0 +1,24 @@
+export const numerologyProfiles = {
+    pythagorean: [
+        "standard",
+        "raw_date",
+        "pythagorean-component-preserve-core-v1",
+        "pythagorean-raw-date-preserve-core-v1",
+    ],
+    chaldean: ["current_name", "birth_name", "chaldean-cheiro-current-name-v1", "chaldean-cheiro-birth-name-v1"],
+    kabbalah: [
+        "standard",
+        "ordinal",
+        "reduced_letters",
+        "reduced_total",
+        "full_letter_names",
+        "full_letter_names_reduced",
+        "kabbalah-gematria-hechrechi-v1",
+        "kabbalah-gematria-siduri-v1",
+        "kabbalah-gematria-katan-v1",
+        "kabbalah-gematria-katan-mispari-v1",
+        "kabbalah-gematria-millui-alef-v1",
+        "kabbalah-gematria-millui-alef-reduced-v1",
+    ],
+    ank_jyotish: ["standard", "ank-jyotish-civil-cheiro-navagraha-reduce-all-v1"],
+};

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

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

package/src/providers/freeastroapi/executors.js

@@ -0,0 +1,18 @@
+import { requiredInputString, defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { freeastroapiActionHandlers, freeastroapiBaseUrl, validateFreeastroapiCredential } from "./runtime.js";
+const service = "freeastroapi";
+export const executors = defineApiKeyProviderExecutors(service, freeastroapiActionHandlers);
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: freeastroapiBaseUrl,
+    auth: { type: "api_key_header", name: "x-api-key" },
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateFreeastroapiCredential(requiredInputString(input.apiKey, "apiKey"), fetcher, signal);
+    },
+};

package/src/providers/freeastroapi/input-validation.d.ts

@@ -0,0 +1,2 @@
+export declare function validateCalendarDate(input: Record<string, unknown>): void;
+export declare function validateExpansionInput(actionName: string, input: Record<string, unknown>): void;