@oomol-lab/open-connector 1.9.0 → 1.9.2

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

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

package/src/providers/agentearth/actions.js

@@ -0,0 +1,100 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const envelope = {
+    error_no: s.literal(0, { description: "Zero indicates a successful request." }),
+    error_msg: s.string("The upstream status message."),
+};
+const tool = s.looseObject("A discovered tool, preserving provider-specific fields.", {
+    tool_name: s.string("The exact tool name."),
+    tool_url: s.string("The complete execution URL; pass it unchanged to execute_tool."),
+    description: s.string("The tool capability description."),
+    when_to_use: s.string("When this tool should be used."),
+    input_schema: s.looseObject("The tool's JSON input schema; usually omitted from list results.", {}),
+    credit: s.number("Credits charged per tool call."),
+    associated_tools: s.string("Related tools suggested by the provider."),
+});
+const toolDiscoveryFields = {
+    ...envelope,
+    total: s.integer("The total number of matching tools."),
+    tools: s.array("Discovered tools.", tool),
+};
+const toolsOutput = s.looseRequiredObject("The upstream tool discovery response.", toolDiscoveryFields);
+export const agentearthActions = [
+    defineProviderAction("agentearth", {
+        name: "get_account",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read the connected AgentEarth account, API key name, and credit balance without discovering tools.",
+        inputSchema: s.requiredObject("No input parameters are required.", {}),
+        outputSchema: s.looseRequiredObject("The authenticated account overview.", {
+            ...envelope,
+            user_id: s.string("The authenticated user ID."),
+            user_name: s.string("The authenticated user name."),
+            key_name: s.string("The API key name, not its secret value."),
+            credit: s.string("The account balance as a decimal string, preserving eight decimal places."),
+        }),
+    }),
+    defineProviderAction("agentearth", {
+        name: "recommend_tools",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Recommend AgentEarth tools for a natural-language task, including input schemas and complete execution URLs.",
+        inputSchema: s.object("Tool recommendation parameters.", {
+            query: s.nonWhitespaceString("The task or question to find tools for."),
+            limit: s.integer("Maximum recommendations; defaults to 5.", {
+                minimum: 1,
+                maximum: 50,
+                default: 5,
+            }),
+        }, { optional: ["limit"] }),
+        outputSchema: toolsOutput,
+    }),
+    defineProviderAction("agentearth", {
+        name: "list_tools",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Browse one page of AgentEarth tools. Increase page to continue; read tool details for the complete input schema before execution.",
+        inputSchema: s.object("Tool browsing parameters.", {
+            page: s.integer("Page number; defaults to 1.", { minimum: 1, default: 1 }),
+            page_size: s.integer("Tools per page; defaults to 20, maximum 100.", {
+                minimum: 1,
+                maximum: 100,
+                default: 20,
+            }),
+            keyword: s.string("A keyword used to filter tools."),
+            sort: s.string("The provider's sorting mode; omit for its default ordering."),
+        }, { required: [] }),
+        outputSchema: s.looseRequiredObject("A page of matching tools.", {
+            ...toolDiscoveryFields,
+            page: s.integer("The returned page number."),
+            page_size: s.integer("The requested number of tools per page."),
+        }),
+    }),
+    defineProviderAction("agentearth", {
+        name: "get_tool_detail",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get the complete input schema and execution URL for an exact AgentEarth tool name returned by discovery.",
+        inputSchema: s.requiredObject("Tool identification.", {
+            tool_name: s.nonWhitespaceString("The exact tool name returned by discovery."),
+        }),
+        outputSchema: toolsOutput,
+    }),
+    defineProviderAction("agentearth", {
+        name: "execute_tool",
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Execute a discovered AgentEarth tool using its complete tool_url and input_schema. Tools may modify or delete external resources and consume credits. Execution waits up to five minutes; after a timeout, verify the outcome before retrying.",
+        inputSchema: s.object("Discovered execution URL and tool arguments.", {
+            tool_url: s.nonWhitespaceString("The complete HTTPS execution URL returned by recommend_tools or get_tool_detail, including all query parameters."),
+            params: s.looseObject("Tool arguments matching the discovered input_schema; use URLs for remote files when supported by the tool.", {}),
+        }, { optional: ["params"] }),
+        outputSchema: s.object("The upstream tool execution response.", {
+            ...envelope,
+            result: {
+                description: "The complete tool result, including any text, image, audio, or resource links.",
+            },
+            platform_annotations: s.string("Optional provider annotations about the result."),
+        }, { required: ["error_no", "error_msg", "result"], additionalProperties: true }),
+    }),
+];

package/src/providers/agentearth/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/agentearth/executors.js

@@ -0,0 +1,109 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { agentearthActions } from "./actions.js";
+const baseUrl = "https://agentearth.ai/agent-api/v1/tool";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+const endpoints = {
+    get_account: "account",
+    recommend_tools: "recommend",
+    list_tools: "list",
+    get_tool_detail: "detail",
+    execute_tool: "execute",
+};
+function executionQuery(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new ProviderRequestError(400, "tool_url must be an AgentEarth execution URL", undefined, "invalid_input");
+    }
+    if (url.origin !== "https://agentearth.ai" ||
+        url.pathname !== "/agent-api/v1/tool/execute" ||
+        url.username ||
+        url.password ||
+        url.hash) {
+        throw new ProviderRequestError(400, "tool_url must use the official AgentEarth HTTPS execution endpoint without credentials or fragments", undefined, "invalid_input");
+    }
+    return url.search;
+}
+async function request({ action, input, apiKey, fetcher, parentSignal }) {
+    const execute = action === "execute_tool";
+    const post = execute || action === "recommend_tools";
+    const query = execute ? executionQuery(input.tool_url) : "";
+    const url = new URL(`${baseUrl}/${endpoints[action]}${query}`);
+    if (!post) {
+        for (const [name, value] of Object.entries(input)) {
+            url.searchParams.set(name, String(value));
+        }
+    }
+    return runProviderRequest({ signal: parentSignal, label: "AgentEarth", timeoutMs: execute ? 300_000 : undefined }, async (signal) => {
+        const response = await fetcher(url.toString(), {
+            method: post ? "POST" : "GET",
+            headers: { ...defaultHeaders, "X-Api-Key": apiKey },
+            body: post ? JSON.stringify(execute ? { params: input.params ?? {} } : input) : undefined,
+            redirect: "manual",
+            signal,
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        const envelope = optionalRecord(payload);
+        if (!response.ok || envelope?.error_no !== 0) {
+            const message = optionalRawString(envelope?.error_msg) || `HTTP ${response.status}; invalid or unsuccessful response`;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `AgentEarth request failed: ${message.split(apiKey).join("[REDACTED]")}`, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return envelope;
+    });
+}
+const handlers = mapProviderActionHandlers("agentearth", agentearthActions, (action) => async (dataInput, context) => {
+    return request({
+        action: action.name,
+        input: dataInput,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("agentearth", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const account = await request({
+            action: "get_account",
+            input: {},
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        return {
+            profile: {
+                displayName: optionalRawString(account.user_name)?.trim() ||
+                    optionalRawString(account.key_name)?.trim() ||
+                    "AgentEarth API Key",
+            },
+            grantedScopes: [],
+            metadata: {},
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "agentearth",
+    baseUrl,
+    auth: { type: "api_key_header", name: "X-Api-Key" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/json", "content-type": "application/json" }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

package/src/providers/aisa/executors.js

@@ -1,5 +1,9 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
+import { readSchemaProperties } from "../../core/json-schema.js";
+import { randomUUIDv7 } from "../../core/uuid-v7.js";
+import { requiredResponseRecord } from "../provider-runtime.js";
 import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, runProviderRequest, } from "../provider-runtime.js";
+import { aisaFirecrawlFamilies } from "./firecrawl-actions.js";
 const service = "aisa";
 const aisaApiOrigin = "https://api.aisa.one";
 function dataForSeoRoute(path, body) {
@@ -50,6 +54,148 @@ const similarwebRowsQuery = {
     trafficSource: "traffic_source",
 };
 const aisaActionRoutes = {
+    ...Object.fromEntries(aisaFirecrawlFamilies.flatMap((family) => {
+        const base = `/apis/v1/firecrawl/${family.path}`;
+        return [
+            [
+                `submit_firecrawl_${family.name}`,
+                {
+                    path: base,
+                    method: "POST",
+                    query: {},
+                    asyncJob: "submit",
+                    body: Object.fromEntries(Object.keys(readSchemaProperties(family.inputSchema))
+                        .filter((key) => key !== "maxPriceUsd")
+                        .map((key) => [key, key])),
+                },
+            ],
+            [
+                `get_firecrawl_${family.name}`,
+                {
+                    path: `${base}/{taskId}`,
+                    query: {},
+                    pathParams: { taskId: "taskId" },
+                    asyncJob: "get",
+                },
+            ],
+            [
+                `cancel_firecrawl_${family.name}`,
+                {
+                    path: `${base}/{taskId}/cancel`,
+                    method: "POST",
+                    query: {},
+                    pathParams: { taskId: "taskId" },
+                    asyncJob: "cancel",
+                },
+            ],
+        ];
+    })),
+    search_exa: {
+        path: "/apis/v1/exa/search",
+        method: "POST",
+        query: {},
+        timeoutMs: 180000,
+        body: {
+            query: "query",
+            stream: "stream",
+            type: "type",
+            numResults: "numResults",
+            category: "category",
+            includeDomains: "includeDomains",
+            excludeDomains: "excludeDomains",
+            startPublishedDate: "startPublishedDate",
+            endPublishedDate: "endPublishedDate",
+            contents: "contents",
+            outputSchema: "outputSchema",
+            systemPrompt: "systemPrompt",
+        },
+    },
+    get_exa_contents: {
+        path: "/apis/v1/exa/contents",
+        method: "POST",
+        query: {},
+        timeoutMs: 180000,
+        bodyDefaults: { text: true },
+        body: {
+            urls: "ids",
+            stream: "stream",
+            text: "text",
+            highlights: "highlights",
+            summary: "summary",
+            livecrawl: "livecrawl",
+            subpages: "subpages",
+        },
+    },
+    answer_exa: {
+        path: "/apis/v1/exa/answer",
+        method: "POST",
+        query: {},
+        timeoutMs: 180000,
+        body: {
+            query: "query",
+            type: "type",
+            stream: "stream",
+            text: "text",
+            outputSchema: "outputSchema",
+        },
+    },
+    scrape_firecrawl: {
+        path: "/apis/v1/firecrawl/scrape",
+        method: "POST",
+        query: {},
+        timeoutMs: 180000,
+        body: { url: "url" },
+        bodyDefaults: { proxy: "basic", formats: ["markdown"], onlyCleanContent: false },
+    },
+    map_firecrawl: {
+        path: "/apis/v1/firecrawl/map",
+        method: "POST",
+        query: {},
+        timeoutMs: 180000,
+        body: { url: "url", limit: "limit" },
+    },
+    crawl_tavily: {
+        path: "/apis/v1/tavily/crawl",
+        method: "POST",
+        query: {},
+        timeoutMs: 180000,
+        body: {
+            url: "url",
+            limit: "limit",
+            maxDepth: "max_depth",
+            maxBreadth: "max_breadth",
+            instructions: "instructions",
+            selectPaths: "select_paths",
+            excludePaths: "exclude_paths",
+            selectDomains: "select_domains",
+            excludeDomains: "exclude_domains",
+            allowExternal: "allow_external",
+            chunksPerSource: "chunks_per_source",
+            extractDepth: "extract_depth",
+            format: "format",
+            includeFavicon: "include_favicon",
+            includeImages: "include_images",
+            includeUsage: "include_usage",
+            timeout: "timeout",
+        },
+    },
+    extract_tavily: {
+        path: "/apis/v1/tavily/extract",
+        method: "POST",
+        query: {},
+        timeoutMs: 90000,
+        body: {
+            urls: "urls",
+            query: "query",
+            chunksPerSource: "chunks_per_source",
+            extractDepth: "extract_depth",
+            format: "format",
+            includeFavicon: "include_favicon",
+            includeImages: "include_images",
+            includeUsage: "include_usage",
+            timeout: "timeout",
+        },
+    },
     get_credits_balance: { path: "/v1/credits/balance", query: {} },
     get_usage: {
         path: "/v1/usage",
@@ -799,9 +945,12 @@ function buildAisaBody(input, route) {
     if (!route.body) {
         return undefined;
     }
-    const body = Object.fromEntries(Object.entries(route.body)
-        .filter(([inputName]) => input[inputName] !== undefined)
-        .map(([inputName, bodyName]) => [bodyName, input[inputName]]));
+    const body = {
+        ...route.bodyDefaults,
+        ...Object.fromEntries(Object.entries(route.body)
+            .filter(([inputName]) => input[inputName] !== undefined)
+            .map(([inputName, bodyName]) => [bodyName, input[inputName]])),
+    };
     const normalized = route.snakeCaseBody ? toSnakeCaseJson(body, route.bodyKeyAliases) : body;
     return route.bodyArray ? [normalized] : normalized;
 }
@@ -866,7 +1015,29 @@ function buildAisaQuery(input, mapping, commaSeparated, joined, fixed, omitDefau
 }
 const handlers = Object.fromEntries(Object.entries(aisaActionRoutes).map(([name, route]) => [
     name,
-    (input, context) => requestAisa(buildAisaPath(route.path, input, route.pathParams), buildAisaQuery(input, route.query, route.commaSeparated ?? [], route.joined ?? {}, route.fixedQuery ?? {}, route.omitQueryDefaults ?? {}), context, route.method ?? "GET", buildAisaBody(input, route), "execute", route.response),
+    async (input, context) => {
+        const normalized = normalizeFirecrawlInput(name, input);
+        const headers = {};
+        if (route.asyncJob === "submit") {
+            headers["Idempotency-Key"] = randomUUIDv7();
+            const maxPriceUsd = optionalString(normalized.maxPriceUsd);
+            if (maxPriceUsd !== undefined)
+                headers["X-AISA-Max-Price-USD"] = maxPriceUsd;
+        }
+        const payload = await requestAisa(buildAisaPath(route.path, normalized, route.pathParams), buildAisaQuery(normalized, route.query, route.commaSeparated ?? [], route.joined ?? {}, route.fixedQuery ?? {}, route.omitQueryDefaults ?? {}), context, route.method ?? "GET", buildAisaBody(normalized, route), "execute", route.response, route.timeoutMs, headers);
+        if (!route.asyncJob)
+            return payload;
+        const job = requiredResponseRecord(payload, "AIsa job");
+        const id = optionalString(job.id);
+        if (!id || (route.asyncJob !== "submit" && !optionalString(job.status)))
+            throw new ProviderRequestError(502, "AIsa returned an invalid job handle or state");
+        if (route.asyncJob !== "submit" && id !== normalized.taskId)
+            throw new ProviderRequestError(502, "AIsa returned a different job");
+        if (route.asyncJob === "submit")
+            return { taskId: id };
+        const { id: _id, object: _object, ...result } = job;
+        return { ...result, taskId: id };
+    },
 ]));
 export const executors = defineApiKeyProviderExecutors(service, handlers, {
     skipDnsValidation: true,
@@ -893,11 +1064,12 @@ export const credentialValidators = {
         };
     },
 };
-async function requestAisa(path, query, context, method, body, phase = "execute", responseFormat) {
-    return runProviderRequest({ signal: context.signal, label: "AIsa" }, async (signal) => {
+async function requestAisa(path, query, context, method, body, phase = "execute", responseFormat, timeoutMs, extraHeaders) {
+    return runProviderRequest({ signal: context.signal, label: "AIsa", timeoutMs }, async (signal) => {
         const url = new URL(path, aisaApiOrigin);
         url.search = query.toString();
         const headers = new Headers({
+            ...extraHeaders,
             accept: responseFormat ? "text/plain, application/json;q=0.9" : "application/json",
             authorization: `Bearer ${context.apiKey}`,
         });
@@ -1046,3 +1218,63 @@ function createAisaError(response, payload, phase) {
 function isCredentialErrorCode(code) {
     return code === "missing_api_key" || code === "invalid_api_key" || code === "revoked_api_key";
 }
+function normalizeFirecrawlInput(name, input) {
+    if (!name.includes("firecrawl"))
+        return input;
+    const normalized = { ...input };
+    const submission = name.startsWith("submit_");
+    const validateUrl = (value) => {
+        const text = String(value).trim();
+        const url = URL.parse(text);
+        if (!url ||
+            url.protocol !== "https:" ||
+            !url.hostname ||
+            ((submission || name === "scrape_firecrawl") && url.pathname.toLowerCase().endsWith(".pdf")) ||
+            (submission && (url.username || url.password || url.hash)))
+            throw providerInputError("Firecrawl requires an HTTPS URL without credentials, fragment or PDF suffix");
+        return text;
+    };
+    if (input.url !== undefined)
+        normalized.url = validateUrl(input.url);
+    if (!submission)
+        return normalized;
+    if (Array.isArray(input.urls)) {
+        const urls = input.urls.map(validateUrl);
+        const unique = urls.map((value) => {
+            while (value.endsWith("/"))
+                value = value.slice(0, -1);
+            return value;
+        });
+        if (new Set(unique).size !== urls.length)
+            throw providerInputError("URLs must be unique after trimming whitespace and trailing slashes");
+        normalized.urls = urls;
+    }
+    if (input.maxPriceUsd !== undefined) {
+        const amount = String(input.maxPriceUsd).trim();
+        if (!amount || !Number.isFinite(Number(amount)) || Number(amount) < 0)
+            throw providerInputError("Expected a non-negative USD amount");
+        normalized.maxPriceUsd = amount;
+    }
+    const normalizeSelectors = (value) => {
+        const output = { ...value };
+        for (const [field, limit] of [
+            ["includeTags", 128],
+            ["excludeTags", 128],
+            ["includePaths", 256],
+            ["excludePaths", 256],
+        ]) {
+            if (!Array.isArray(value[field]))
+                continue;
+            output[field] = value[field].map((entry) => {
+                const text = String(entry).trim();
+                if (!text || Buffer.byteLength(text) > limit || text.includes("\r") || text.includes("\n"))
+                    throw providerInputError(`${field} entries must fit ${limit} UTF-8 bytes and contain no newlines`);
+                return text;
+            });
+        }
+        return output;
+    };
+    if (optionalRecord(input.scrapeOptions))
+        normalized.scrapeOptions = normalizeSelectors(optionalRecord(input.scrapeOptions));
+    return normalizeSelectors(normalized);
+}

package/src/providers/aisa/firecrawl-actions.d.ts

@@ -0,0 +1,9 @@
+import type { ActionDefinition, JsonSchema } from "../../core/types.ts";
+interface FirecrawlFamily {
+    name: string;
+    path: string;
+    inputSchema: JsonSchema;
+}
+export declare const aisaFirecrawlFamilies: FirecrawlFamily[];
+export declare const aisaFirecrawlActions: readonly ActionDefinition[];
+export {};

package/src/providers/aisa/firecrawl-actions.js

@@ -0,0 +1,115 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const actionLifecycles = {
+    submit_firecrawl_crawl: { startActionId: "aisa.submit_firecrawl_crawl", statusActionId: "aisa.get_firecrawl_crawl" },
+    submit_firecrawl_batch_scrape: {
+        startActionId: "aisa.submit_firecrawl_batch_scrape",
+        statusActionId: "aisa.get_firecrawl_batch_scrape",
+    },
+};
+const url = s.string("HTTPS URL without credentials, fragment or PDF suffix.", {
+    format: "uri",
+});
+const tags = (description) => s.nullable(s.array(description, s.nonEmptyString("An HTML tag selector, up to 128 UTF-8 bytes."), {
+    maxItems: 50,
+}));
+const scrapeProperties = {
+    includeTags: tags("Only include matching HTML tags."),
+    excludeTags: tags("Exclude matching HTML tags."),
+    onlyMainContent: s.nullable(s.boolean("Extract only the main page content.")),
+    maxAge: s.nullable(s.integer("Maximum cached content age in milliseconds.", { minimum: 0, maximum: 31536000000 })),
+    minAge: s.nullable(s.integer("Minimum cached content age in milliseconds.", { minimum: 0, maximum: 31536000000 })),
+    timeout: s.nullable(s.integer("Per-page scrape timeout in milliseconds.", { minimum: 1000, maximum: 300000 })),
+};
+const submissionProperties = {
+    maxPriceUsd: s.string("Optional AIsa admission authorization in USD; not a guarantee of the final charge.", {
+        minLength: 1,
+    }),
+};
+const paths = (description) => s.nullable(s.array(description, s.nonEmptyString("A path pattern, up to 256 UTF-8 bytes."), {
+    maxItems: 20,
+}));
+const concurrency = s.nullable(s.integer("Maximum concurrent page requests.", { minimum: 1, maximum: 20 }));
+const crawlInput = s.object("Submit an asynchronous website crawl through AIsa.", {
+    ...submissionProperties,
+    url,
+    limit: s.integer("Maximum pages to crawl.", { minimum: 1, maximum: 1000 }),
+    allowExternalLinks: s.nullable(s.boolean("Allow links to external websites.")),
+    allowSubdomains: s.nullable(s.boolean("Allow crawling subdomains.")),
+    crawlEntireDomain: s.nullable(s.boolean("Crawl across the entire domain.")),
+    delay: s.nullable(s.number("Delay between requests in seconds.", { minimum: 0, maximum: 30 })),
+    excludePaths: paths("Path patterns to exclude from crawling."),
+    includePaths: paths("Path patterns to include in crawling."),
+    ignoreQueryParameters: s.nullable(s.boolean("Ignore query parameters when identifying pages.")),
+    maxConcurrency: concurrency,
+    maxDiscoveryDepth: s.nullable(s.integer("Maximum link discovery depth.", { minimum: 0, maximum: 10 })),
+    scrapeOptions: s.nullable(s.object("Options applied to each crawled page.", scrapeProperties, { required: [] })),
+    sitemap: s.nullable(s.stringEnum("How to use the website sitemap.", ["skip", "include", "only"])),
+}, { required: ["url", "limit"] });
+const batchInput = s.object("Submit an asynchronous batch of known page URLs through AIsa.", {
+    ...submissionProperties,
+    ...scrapeProperties,
+    maxConcurrency: concurrency,
+    urls: s.array("Distinct page URLs; duplicates after trimming trailing slashes are not allowed.", url, {
+        minItems: 1,
+        maxItems: 1000,
+        uniqueItems: true,
+    }),
+}, { required: ["urls"] });
+export const aisaFirecrawlFamilies = [
+    { name: "crawl", path: "crawl", inputSchema: crawlInput },
+    { name: "batch_scrape", path: "batch-scrape", inputSchema: batchInput },
+];
+const taskId = s.string("Task ID returned by submission; use it with the same connection.", {
+    minLength: 1,
+});
+const jobOutput = s.looseObject("The job state, output and authoritative final pricing when available.", {
+    taskId,
+    status: s.string("Job state: queued, running, completed, failed or cancelled."),
+    output: s.unknown("Upstream crawl or batch scrape output; may be unavailable before completion or after expiry."),
+    outputExpired: s.nullable(s.boolean("Whether the upstream output has expired.")),
+    error: s.nullable(s.looseObject("Upstream job error details.")),
+    pricing: s.nullable(s.looseObject("AIsa pricing information, in micro-USD.", {
+        authorizedMicrosUSD: s.nullable(s.integer("Initially authorized amount; not the final charge.")),
+        finalMicrosUSD: s.nullable(s.integer("Final customer charge; null means unknown, zero means no charge.")),
+        currency: s.nullable(s.string("Pricing currency.")),
+        billingMode: s.nullable(s.string("AIsa billing mode.")),
+    })),
+});
+export const aisaFirecrawlActions = aisaFirecrawlFamilies.flatMap((family) => [
+    defineProviderAction("aisa", {
+        name: `submit_firecrawl_${family.name}`,
+        operationType: "write",
+        requiredScopes: [],
+        description: family.name === "crawl"
+            ? "Start a background website crawl through AIsa Firecrawl. Poll the returned task ID for results."
+            : "Start a background batch scrape of known URLs through AIsa Firecrawl. Poll the returned task ID for results.",
+        inputSchema: family.inputSchema,
+        outputSchema: s.object("The submitted task handle.", { taskId }, {
+            optional: [],
+        }),
+        asyncLifecycle: actionLifecycles[`submit_firecrawl_${family.name}`],
+    }),
+    defineProviderAction("aisa", {
+        name: `get_firecrawl_${family.name}`,
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get a Firecrawl task state and results. Check outputExpired and job errors even when the task has finished.",
+        inputSchema: s.object("Identify the task to query.", { taskId }, {
+            optional: [],
+        }),
+        outputSchema: jobOutput,
+        asyncLifecycle: actionLifecycles[`get_firecrawl_${family.name}`],
+    }),
+    defineProviderAction("aisa", {
+        name: `cancel_firecrawl_${family.name}`,
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Request cancellation of a Firecrawl task. Work already performed may still be charged; poll the task for final state and pricing.",
+        inputSchema: s.object("Identify the task to cancel.", { taskId }, {
+            optional: [],
+        }),
+        outputSchema: jobOutput,
+        asyncLifecycle: actionLifecycles[`cancel_firecrawl_${family.name}`],
+    }),
+]);

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

@@ -0,0 +1,9 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const aktaActions: ActionDefinition[];
+interface AktaRoute {
+    method: string;
+    path: string;
+    timeoutMs?: number;
+}
+export declare const aktaRoutes: Record<string, AktaRoute>;
+export {};