@oomol-lab/open-connector 1.9.1 → 1.9.2

package/src/providers/surf/shared-schemas.d.ts

@@ -0,0 +1,18 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const orderSchema: JsonSchema;
+export declare const financialPeriodLimitSchema: JsonSchema;
+export declare const endDateSchema: JsonSchema;
+export declare const evmWalletAddressSchema: JsonSchema;
+export declare const polymarketConditionIdSchema: JsonSchema;
+export declare const conditionIdSchema: JsonSchema;
+export declare const fromSchema: JsonSchema;
+export declare const metaSchema: JsonSchema;
+export declare const projectSearchQuerySchema: JsonSchema;
+export declare const dataSchema: JsonSchema;
+export declare const exchangeMarketTypeSchema: JsonSchema;
+export declare const kalshiTickerSchema: JsonSchema;
+export declare const timeRangeSchema: JsonSchema;
+export declare const projectIdSchema: JsonSchema;
+export declare const objectResponseSchema: JsonSchema;
+export declare const arrayResponseSchema: JsonSchema;
+export declare const sqlJobResponseSchema: JsonSchema;

package/src/providers/surf/shared-schemas.js

@@ -0,0 +1,37 @@
+import { s } from "../../core/json-schema.js";
+export const orderSchema = s.withExamples(s.withEnum(s.string('Sort order Default: "desc".'), ["asc", "desc"]), ["desc"]);
+export const financialPeriodLimitSchema = s.integer("Maximum financial periods to return Default: 5.", {
+    minimum: 1,
+    maximum: 100,
+});
+export const endDateSchema = s.withExamples(s.string("Inclusive latest period end date in YYYY-MM-DD format"), ["2024-12-31"]);
+export const evmWalletAddressSchema = s.string("Wallet address: a 0x EVM address or an ENS name (e.g. vitalik.eth). Solana addresses are not supported.");
+export const polymarketConditionIdSchema = s.withExamples(s.string("Polymarket condition ID"), [
+    "0x6fefc0438c7598b23531457c8c60541990d0786bd4bd9dfc3eabc8d95c291092",
+]);
+export const conditionIdSchema = s.withExamples(s.string("Market condition identifier"), [
+    "0x6fefc0438c7598b23531457c8c60541990d0786bd4bd9dfc3eabc8d95c291092",
+]);
+export const fromSchema = s.withExamples(s.string("Start of time range. Accepts Unix seconds (`1704067200`) or date string (`2024-01-01`)"), ["2024-01-01"]);
+export const metaSchema = s.object("Upstream response metadata, including pagination cursors, limits, and credits when supplied.", {}, { required: [], additionalProperties: true });
+export const projectSearchQuerySchema = s.withExamples(s.string("Fuzzy entity name search. Only use when 'id' is not available. May return unexpected results for ambiguous names."), ["ethereum"]);
+export const dataSchema = s.nullable(s.array("Upstream result data, preserving all provider fields.", {
+    description: "Upstream result item, preserving all provider fields.",
+}));
+export const exchangeMarketTypeSchema = s.withExamples(s.withEnum(s.string('Market type: spot for spot trading, swap/perpetual/perp for perpetual contracts Default: "spot".'), ["spot", "swap", "perpetual", "perp"]), ["spot"]);
+export const kalshiTickerSchema = s.withExamples(s.string("Market ticker identifier. Use GET /v1/prediction-market/kalshi/markets or GET /v1/search/prediction-market?platform=kalshi&q={keyword} to discover valid tickers."), ["KXBTC2026250-27JAN01-250000"]);
+export const timeRangeSchema = s.withExamples(s.withEnum(s.string('Window of history to return: `7d`, `30d`, `90d`, `180d`, or `1y`. This endpoint uses `time_range` only — it does NOT accept `interval`. Default: "30d".'), ["7d", "30d", "90d", "180d", "1y"]), ["30d"]);
+export const projectIdSchema = s.withExamples(s.string("Surf project UUID. PREFERRED — always use this when available from a previous response (e.g. project_id from /fund/portfolio or id from /search/project). Takes priority over q."), ["25c6612a-395c-4974-94eb-3b5f9f4b2ed7"]);
+export const objectResponseSchema = s.object("Surf response with the original provider envelope and fields.", {
+    $schema: s.string("Response JSON Schema URL."),
+    data: s.object("Upstream result data, preserving all provider fields.", {}, { required: [], additionalProperties: true }),
+    meta: metaSchema,
+}, { required: [], additionalProperties: true });
+export const arrayResponseSchema = s.object("Surf response with the original provider envelope and fields.", { $schema: s.string("Response JSON Schema URL."), data: dataSchema, meta: metaSchema }, { required: [], additionalProperties: true });
+export const sqlJobResponseSchema = s.object("Surf response with the original provider envelope and fields.", {
+    $schema: s.string("Response JSON Schema URL."),
+    data: s.object("Upstream result data, preserving all provider fields.", {}, { required: [], additionalProperties: true }),
+    meta: metaSchema,
+    job_id: s.string("Asynchronous SQL job identifier, promoted from data.job_id."),
+    status: s.string("Asynchronous SQL job state, promoted from data.status."),
+}, { required: [], additionalProperties: true });

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const triggers: readonly IntegrationDefinition[];
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;

package/src/providers/tally/executors.js

@@ -1,6 +1,8 @@
 import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { tallyActionHandlers, tallyApiBaseUrl, validateTallyCredential } from "./runtime.js";
+import { tallyFormResponse } from "./trigger-on-form-response.js";
 const service = "tally";
+export const triggers = [tallyFormResponse];
 export const executors = defineApiKeyProviderExecutors(service, tallyActionHandlers);
 export const proxy = defineProviderProxy({
     service,

package/src/providers/tally/trigger-on-form-response.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const tallyFormResponse: IntegrationDefinition;

package/src/providers/tally/trigger-on-form-response.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/tally/trigger-on-form-response.definition.js

@@ -0,0 +1,54 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "formId",
+            jsonSchema: { ...s.string({ minLength: 1, maxLength: 128 }), title: "Form" },
+            nullable: false,
+            description: "Choose a form accessible to this Connection.",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Receives new Tally form submissions through a signed, automatically managed webhook.",
+    displayName: "Form Response",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 200,
+    },
+    key: "tally.on_form_response",
+    name: "on_form_response",
+    outputs: [
+        {
+            handle: "response",
+            nullable: false,
+            jsonSchema: {
+                type: "object",
+                properties: {
+                    eventId: s.string(),
+                    createdAt: s.string(),
+                    formId: s.string(),
+                    submissionId: s.string(),
+                    responseId: s.string(),
+                    fields: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                key: s.string(),
+                                type: s.string(),
+                                label: { type: ["string", "null"] },
+                                value: {},
+                                options: { type: "array", items: { type: "object" } },
+                            },
+                            required: ["key", "type", "label", "value"],
+                        },
+                    },
+                },
+                required: ["eventId", "createdAt", "formId", "submissionId", "responseId", "fields"],
+            },
+        },
+    ],
+    provider: "tally",
+    type: "integration",
+};

package/src/providers/tally/trigger-on-form-response.js

@@ -0,0 +1,166 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { bytes, verifyBase64Hmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-form-response.definition.js";
+export const tallyFormResponse = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async configOptions(context) {
+        if (context.field != "formId")
+            throw new PermanentIntegrationError("Unknown Tally configuration field.");
+        const options = [];
+        for (let page = 1; page <= 100; page++) {
+            const result = await request(context, { endpoint: "/forms", method: "GET", query: { page, limit: 100 } });
+            success(result);
+            const data = pageData(result.data, "items", page);
+            for (const form of data.items) {
+                if (!isJsonObject(form) || !nonempty(form.id) || typeof form.name != "string")
+                    throw new TransientIntegrationError("Tally returned an invalid form.");
+                options.push({ value: form.id, label: form.name || form.id });
+            }
+            if (!data.hasMore)
+                return options;
+        }
+        throw new PermanentIntegrationError("The Tally form list exceeds 10000 entries.");
+    },
+    async receive(context) {
+        // Tally signs the parsed JSON serialization rather than transport whitespace.
+        if (!(await verifyBase64Hmac(context.callbackSecret, [bytes(JSON.stringify(context.payload))], context.header("tally-signature"))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) || payload.eventType != "FORM_RESPONSE")
+            return { outcome: "ignored", reason: "Tally event is not a form response." };
+        const data = payload.data;
+        if (!isJsonObject(data) || data.formId != context.config.formId)
+            return { outcome: "ignored", reason: "Tally form does not match this subscription." };
+        if (!nonempty(payload.eventId) ||
+            !nonempty(payload.createdAt) ||
+            !nonempty(data.submissionId) ||
+            !nonempty(data.responseId) ||
+            !Array.isArray(data.fields) ||
+            data.fields.some((field) => !isJsonObject(field) ||
+                !nonempty(field.key) ||
+                !nonempty(field.type) ||
+                (field.label !== null && typeof field.label != "string") ||
+                !("value" in field) ||
+                ("options" in field &&
+                    (!Array.isArray(field.options) || field.options.some((option) => !isJsonObject(option))))))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: payload.eventId,
+            outputs: { response: { ...data, eventId: payload.eventId, createdAt: payload.createdAt } },
+        };
+    },
+    async reconcile(context) {
+        const state = context.state;
+        if (state == null)
+            throw new PermanentIntegrationError("Tally subscription state is missing.");
+        const formId = context.config.formId;
+        if (!nonempty(formId))
+            throw new PermanentIntegrationError("Choose a Tally form.");
+        let hookId = nonempty(state.subscription.hookId) ? state.subscription.hookId : undefined;
+        if (hookId == null) {
+            for (let page = 1; page <= 100; page++) {
+                const result = await request(context, { endpoint: "/webhooks", method: "GET", query: { page, limit: 100 } });
+                success(result);
+                const data = pageData(result.data, "webhooks", page);
+                for (const hook of data.items) {
+                    if (!isJsonObject(hook) || !nonempty(hook.id) || !nonempty(hook.formId) || typeof hook.url != "string")
+                        throw new TransientIntegrationError("Tally returned an invalid webhook.");
+                    if (hook.formId == formId && hook.url == context.endpointUrl) {
+                        if (hookId != null)
+                            throw new PermanentIntegrationError("Multiple Tally webhooks match this subscription. Remove duplicates before retrying.");
+                        hookId = hook.id;
+                    }
+                }
+                if (!data.hasMore)
+                    break;
+                if (page == 100)
+                    throw new PermanentIntegrationError("The Tally webhook list exceeds 10000 entries.");
+            }
+        }
+        if (!context.active) {
+            if (hookId != null) {
+                const result = await request(context, {
+                    endpoint: `/webhooks/${encodeURIComponent(hookId)}`,
+                    method: "DELETE",
+                });
+                if (result.status != 404)
+                    success(result);
+            }
+            else if (state.subscription.creating === true) {
+                throw new PermanentIntegrationError("Tally webhook creation has an uncertain outcome. Verify the remote subscription before cleanup.");
+            }
+            await state.saveSubscription({}, later(context.now));
+            return { outcome: "ready" };
+        }
+        if (hookId == null) {
+            if (state.subscription.creating === true)
+                throw new PermanentIntegrationError("Tally webhook creation has an uncertain outcome. Retry after verifying the remote subscription.");
+            await state.saveSubscription({ creating: true }, context.now);
+            const result = await request(context, {
+                endpoint: "/webhooks",
+                method: "POST",
+                body: {
+                    formId,
+                    url: context.endpointUrl,
+                    eventTypes: ["FORM_RESPONSE"],
+                    signingSecret: context.callbackSecret,
+                },
+            });
+            if (result.status >= 400 && result.status < 500)
+                await state.saveSubscription({}, context.now);
+            success(result);
+            if (!isJsonObject(result.data) || !nonempty(result.data.id))
+                throw new TransientIntegrationError("Tally webhook creation returned no identity.");
+            hookId = result.data.id;
+        }
+        await state.saveSubscription({ hookId }, context.now);
+        const aligned = await request(context, {
+            endpoint: `/webhooks/${encodeURIComponent(hookId)}`,
+            method: "PATCH",
+            body: {
+                url: context.endpointUrl,
+                eventTypes: ["FORM_RESPONSE"],
+                signingSecret: context.callbackSecret,
+                isEnabled: true,
+            },
+        });
+        if (aligned.status == 404) {
+            await state.saveSubscription({}, context.now);
+            return { outcome: "pending" };
+        }
+        success(aligned);
+        await state.saveSubscription({ hookId }, later(context.now));
+        return { outcome: "ready" };
+    },
+};
+function nonempty(value) {
+    return typeof value == "string" && value.length > 0;
+}
+function pageData(value, field, page) {
+    if (!isJsonObject(value) ||
+        !Array.isArray(value[field]) ||
+        typeof value.hasMore != "boolean" ||
+        value.page !== page ||
+        (value.hasMore && value[field].length == 0))
+        throw new TransientIntegrationError("Tally returned an invalid page.");
+    return { items: value[field], hasMore: value.hasMore };
+}
+async function request(context, input) {
+    context.signal?.throwIfAborted();
+    const result = await context.connector.execute(input, context.signal);
+    context.signal?.throwIfAborted();
+    return result;
+}
+function success(result) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status >= 400 && result.status < 500 && result.status != 429)
+        throw new PermanentIntegrationError(`Tally rejected the subscription request (HTTP ${result.status}). Check form access and API key permissions.`);
+    throw new TransientIntegrationError(`Tally subscription request failed (HTTP ${result.status}).`);
+}
+function later(now) {
+    return new Date(now.getTime() + 24 * 60 * 60 * 1000);
+}

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

@@ -0,0 +1,6 @@
+import type { ActionDefinition } from "../../core/types.ts";
+import type { TinyfishEndpoint } from "./endpoints.ts";
+declare const tinyfishEndpoints: TinyfishEndpoint[];
+export declare const tinyfishEndpointByName: Map<string, (typeof tinyfishEndpoints)[number]>;
+export declare const tinyfishActions: ActionDefinition[];
+export {};

package/src/providers/tinyfish/actions.js

@@ -0,0 +1,19 @@
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { agentEndpoints } from "./agent-actions.js";
+import { dataEndpoints } from "./data-actions.js";
+import { managementEndpoints } from "./management-actions.js";
+const actionLifecycles = {
+    submit_run: { startActionId: "tinyfish.submit_run", statusActionId: "tinyfish.get_run" },
+    start_research: { startActionId: "tinyfish.start_research", statusActionId: "tinyfish.get_research_run" },
+};
+const tinyfishEndpoints = [...agentEndpoints, ...dataEndpoints, ...managementEndpoints];
+export const tinyfishEndpointByName = new Map(tinyfishEndpoints.map((endpoint) => [endpoint.name, endpoint]));
+export const tinyfishActions = tinyfishEndpoints.map((endpoint) => defineProviderAction("tinyfish", {
+    name: endpoint.name,
+    description: endpoint.description,
+    operationType: endpoint.operationType,
+    requiredScopes: [],
+    inputSchema: endpoint.inputSchema,
+    outputSchema: endpoint.outputSchema,
+    asyncLifecycle: actionLifecycles[endpoint.name],
+}));

package/src/providers/tinyfish/agent-actions.d.ts

@@ -0,0 +1,2 @@
+import type { TinyfishEndpoint } from "./endpoints.ts";
+export declare const agentEndpoints: TinyfishEndpoint[];

package/src/providers/tinyfish/agent-actions.js

@@ -0,0 +1,268 @@
+import { s } from "../../core/json-schema.js";
+const runStatus = s.stringEnum("Current automation run status.", [
+    "PENDING",
+    "RUNNING",
+    "COMPLETED",
+    "FAILED",
+    "CANCELLED",
+]);
+const runId = s.nonEmptyString("Automation run ID.", { pattern: "^[A-Za-z0-9_-]+$" });
+const outputSchema = s.record("Provider-supported structured-output schema subset. Unsupported schema keywords are rejected by TinyFish.", true);
+const profileId = s.nonEmptyString("Browser Context Profile ID to use when use_profile is true.");
+const runProperties = {
+    url: s.url("Target website URL to automate."),
+    goal: s.nonEmptyString("Natural language description of the task to perform on the website."),
+    browser_profile: s.stringEnum("Browser profile: lite uses a standard browser; stealth enables anti-detection.", [
+        "lite",
+        "stealth",
+    ]),
+    api_integration: s.string("Integration name used for analytics."),
+    agent_config: s.object("Agent behavior configuration.", {
+        mode: s.stringEnum("Strict mode enables fail-fast behavior for test automation.", ["default", "strict"]),
+        cursor_style: s.stringEnum("Browser agent cursor style.", ["fish", "standard", "green-pointer"]),
+        max_steps: s.integer("Maximum tool-call steps; the provider default is 150.", {
+            minimum: 1,
+            maximum: 500,
+        }),
+        max_duration_seconds: s.integer("Maximum wall-clock execution time in seconds. Omit for no limit.", {
+            minimum: 1,
+        }),
+    }, { required: [] }),
+    capture_config: s.object("Data to capture during the run.", {
+        elements: s.boolean("Capture page elements."),
+        snapshots: s.boolean("Capture browser snapshots."),
+        screenshots: s.boolean("Capture screenshots."),
+        recording: s.boolean("Record the browser session."),
+        html: s.boolean("Capture full-page HTML snapshots."),
+    }, { required: [] }),
+    webhook_url: s.url("HTTPS URL for run lifecycle webhook notifications."),
+    use_vault: s.boolean("Use enabled vault credentials for this run. Defaults to false."),
+    use_profile: s.boolean("Use a Browser Context Profile. If profiles are enabled and no profile_id is given, a default profile must exist. Legacy calls are ignored when profiles are disabled."),
+    credential_item_ids: s.stringArray("Credential URIs to use. Requires use_vault=true; omit to use all enabled items.", { minItems: 1, itemDescription: "Vault credential URI." }),
+    proxy_config: s.object("Browser proxy configuration.", {
+        enabled: s.boolean("Enable a proxy for this run."),
+        country_code: s.string("Proxy exit country as ISO 3166-1 alpha-2; defaults to US."),
+    }, { required: ["enabled"] }),
+};
+const runInput = s.object("Browser automation task parameters.", {
+    ...runProperties,
+    profile_id: profileId,
+    output_schema: outputSchema,
+}, { required: ["url", "goal"] });
+const errorSchema = s.nullable(s.looseObject("Provider error details, including retry guidance and profile setup hints.", {
+    code: s.string("Machine-readable error code."),
+    message: s.string("Human-readable error message."),
+    category: s.string("Error category: SYSTEM_FAILURE, AGENT_FAILURE, BILLING_FAILURE, or UNKNOWN."),
+    retry_after: s.nullableNumber("Suggested retry delay in seconds, or null when not retryable."),
+    help_url: s.string("Troubleshooting documentation URL."),
+    help_message: s.string("Troubleshooting guidance."),
+    details: { description: "Additional provider error details, including validation errors." },
+}));
+const profileHint = s.looseObject("Profile setup guidance for authentication walls or bot challenges.", {
+    message: s.string("Human-readable setup guidance."),
+    setup_url: s.string("Profile setup URL."),
+    reason: s.string("Reason a profile may help: auth_wall or bot_challenge."),
+});
+const runSummaryProperties = {
+    run_id: runId,
+    status: runStatus,
+    goal: s.string("Natural language goal for this automation run."),
+    created_at: s.string("Run creation timestamp."),
+    started_at: s.nullableString("Run start timestamp, or null before execution."),
+    finished_at: s.nullableString("Run completion timestamp, or null before completion."),
+    num_of_steps: s.nullableInteger("Number of automation steps; null while in progress.", {
+        minimum: 0,
+    }),
+    result: s.nullable(s.record("Extracted structured result.", true)),
+    output_schema: s.nullable(outputSchema),
+    profile_attached: s.boolean("Whether a Browser Context Profile was attached."),
+    profile_id: s.nullableString("Attached Browser Context Profile ID, or null."),
+    error: errorSchema,
+    profile_hint: profileHint,
+    streaming_url: s.nullableString("Live browser session URL, available while running."),
+    browser_config: s.nullable(s.looseObject("Browser configuration used by the run.", {
+        proxy_enabled: s.nullableBoolean("Whether a proxy was enabled."),
+        proxy_country_code: s.nullableString("Proxy exit country code."),
+    })),
+};
+const runDetail = s.object("Automation run details and captured steps.", {
+    ...runSummaryProperties,
+    video_url: s.nullableString("Presigned recording URL, expiring after 15 minutes, or null."),
+    steps: s.array("Steps performed during this run.", s.looseObject("An automation step.", {
+        id: s.string("Step event ID."),
+        timestamp: s.string("Step timestamp."),
+        status: runStatus,
+        action: s.nullableString("Description of the performed action."),
+        screenshot: s.nullableString("Screenshot URL or data URI according to the requested delivery mode, or null."),
+        html: s.nullableString("HTML snapshot URL, or null. Requires capture_config.html when submitting."),
+        duration: s.nullableString("Step duration."),
+    })),
+}, {
+    required: ["run_id", "status"],
+    additionalProperties: true,
+});
+const cancellation = s.looseObject("Cancellation result; terminal runs retain their existing status.", {
+    run_id: runId,
+    status: s.stringEnum("Final run status.", ["CANCELLED", "COMPLETED", "FAILED"]),
+    cancelled_at: s.nullableString("Cancellation timestamp, or null when not cancelled."),
+    message: s.nullableString("Additional cancellation context."),
+});
+const batchIds = s.requiredObject("Run IDs to retrieve or cancel.", {
+    run_ids: s.stringArray("Run IDs.", {
+        minItems: 1,
+        maxItems: 100,
+        itemDescription: "Automation run ID.",
+    }),
+});
+const notFound = s.nullable(s.stringArray("Run IDs not found or not owned; null if all were found.", {
+    itemDescription: "Unresolved run ID.",
+}));
+const fileOutput = s.requiredObject("Captured file uploaded to file transit.", {
+    url: s.url("Download URL of the captured file."),
+    mimeType: s.string("Captured file MIME type."),
+});
+const stepInput = s.requiredObject("Run and captured step identifiers.", {
+    id: runId,
+    stepId: s.nonEmptyString("Step event ID.", { pattern: "^[A-Za-z0-9_-]+$" }),
+});
+export const agentEndpoints = [
+    {
+        name: "submit_run",
+        description: "Submit a browser automation task asynchronously. The agent can perform arbitrary website operations; use get_run to retrieve progress and results.",
+        operationType: "destructive",
+        origin: "main",
+        method: "POST",
+        path: "/v1/automation/run-async",
+        inputSchema: runInput,
+        outputSchema: s.looseObject("Asynchronous automation submission.", {
+            run_id: s.nullableString("Created run ID; null if creation failed."),
+            error: errorSchema,
+        }),
+    },
+    {
+        name: "submit_run_batch",
+        description: "Atomically submit 1–100 browser automation tasks. Shared profile_id and output_schema apply to the batch. Retrieve each run using get_run or get_runs.",
+        operationType: "destructive",
+        origin: "main",
+        method: "POST",
+        path: "/v1/automation/run-batch",
+        inputSchema: s.object("Batch automation parameters.", {
+            runs: s.array("Automation tasks.", s.object("One automation task.", runProperties, { required: ["url", "goal"] }), { minItems: 1, maxItems: 100 }),
+            profile_id: profileId,
+            output_schema: outputSchema,
+        }, { required: ["runs"] }),
+        outputSchema: s.looseObject("Atomic batch submission result.", {
+            run_ids: s.nullable(s.stringArray("Created run IDs, or null on failure.", {
+                itemDescription: "Created run ID.",
+            })),
+            error: errorSchema,
+        }),
+    },
+    {
+        name: "list_runs",
+        description: "List and search automation runs with cursor pagination, status, goal, and creation-time filters.",
+        operationType: "read",
+        origin: "main",
+        method: "GET",
+        path: "/v1/runs",
+        queryKeys: ["status", "goal", "created_after", "created_before", "sort_direction", "cursor", "limit"],
+        inputSchema: s.object("Run search and pagination parameters.", {
+            status: runStatus,
+            goal: s.string("Case-insensitive partial goal text filter.", { maxLength: 500 }),
+            created_after: s.string("Filter runs created after this ISO 8601 timestamp.", {
+                format: "date-time",
+            }),
+            created_before: s.string("Filter runs created before this ISO 8601 timestamp.", {
+                format: "date-time",
+            }),
+            sort_direction: s.stringEnum("Sort order by creation time; defaults to desc.", ["asc", "desc"]),
+            cursor: s.string("Pagination cursor from the previous response."),
+            limit: s.integer("Maximum results; defaults to 20.", { minimum: 1, maximum: 100 }),
+        }, { required: [] }),
+        outputSchema: s.looseObject("Paginated automation runs.", {
+            data: s.array("Run summaries without steps and video URLs.", s.looseObject("Automation run summary.", runSummaryProperties)),
+            pagination: s.looseObject("Pagination information.", {
+                total: s.integer("Total matching runs."),
+                next_cursor: s.nullableString("Next-page cursor; null on the last page."),
+                has_more: s.boolean("Whether more results exist."),
+            }),
+        }),
+    },
+    {
+        name: "get_runs",
+        description: "Retrieve up to 100 automation runs, including per-run results, steps, and missing IDs.",
+        operationType: "read",
+        origin: "main",
+        method: "POST",
+        path: "/v1/runs/batch",
+        inputSchema: batchIds,
+        outputSchema: s.looseObject("Batch run retrieval result.", {
+            data: s.array("Found automation runs.", runDetail),
+            not_found: notFound,
+        }),
+    },
+    {
+        name: "cancel_runs",
+        description: "Cancel up to 100 automation runs. Already terminal runs retain their existing status; missing IDs are returned separately.",
+        operationType: "destructive",
+        origin: "main",
+        method: "POST",
+        path: "/v1/runs/batch/cancel",
+        inputSchema: batchIds,
+        outputSchema: s.looseObject("Batch cancellation result.", {
+            results: s.array("Per-run cancellation results.", cancellation),
+            not_found: notFound,
+        }),
+    },
+    {
+        name: "get_run",
+        description: "Retrieve an automation run and captured steps. Prefer screenshot URLs for JSON clients; use get_step_screenshot or get_step_html to transfer captured files.",
+        operationType: "read",
+        origin: "main",
+        method: "GET",
+        path: "/v1/runs/{id}",
+        pathKeys: ["id"],
+        queryKeys: ["screenshots", "html"],
+        inputSchema: s.object("Run details and capture delivery options.", {
+            id: runId,
+            screenshots: s.stringEnum("Screenshot delivery mode; defaults to url. Base64 embeds potentially large data URIs.", ["base64", "url", "none"]),
+            html: s.stringEnum("HTML snapshot delivery mode; defaults to url and requires capture_config.html at submission.", ["url", "none"]),
+        }, { required: ["id"] }),
+        outputSchema: runDetail,
+    },
+    {
+        name: "cancel_run",
+        description: "Cancel an asynchronous automation run. Already terminal runs retain their status. Runs started through the synchronous API cannot be cancelled.",
+        operationType: "destructive",
+        origin: "main",
+        method: "POST",
+        path: "/v1/runs/{id}/cancel",
+        pathKeys: ["id"],
+        inputSchema: s.requiredObject("Run to cancel.", { id: runId }),
+        outputSchema: cancellation,
+    },
+    {
+        name: "get_step_screenshot",
+        description: "Download a captured automation-step screenshot and return a file-transit URL.",
+        operationType: "read",
+        origin: "main",
+        method: "GET",
+        path: "/v1/runs/{id}/steps/{stepId}/screenshot",
+        pathKeys: ["id", "stepId"],
+        inputSchema: stepInput,
+        outputSchema: fileOutput,
+        responseType: "screenshot",
+    },
+    {
+        name: "get_step_html",
+        description: "Download a captured automation-step HTML snapshot and return a file-transit URL. Requires capture_config.html when submitting the run.",
+        operationType: "read",
+        origin: "main",
+        method: "GET",
+        path: "/v1/runs/{id}/steps/{stepId}/html",
+        pathKeys: ["id", "stepId"],
+        inputSchema: stepInput,
+        outputSchema: fileOutput,
+        responseType: "html",
+    },
+];

package/src/providers/tinyfish/data-actions.d.ts

@@ -0,0 +1,2 @@
+import type { TinyfishEndpoint } from "./endpoints.ts";
+export declare const dataEndpoints: TinyfishEndpoint[];