@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/tinyfish/research-schemas.js

@@ -0,0 +1,71 @@
+import { s } from "../../core/json-schema.js";
+export const researchStatus = s.stringEnum("Research run state.", [
+    "RUNNING",
+    "COMPLETED",
+    "FAILED",
+    "CANCELLED",
+    "TIMED_OUT",
+    "QUEUED",
+]);
+export const researchId = s.string("Research run identifier.", { minLength: 1 });
+export const researchInput = {
+    ...s.object("Asynchronous research parameters.", {
+        query: s.string("Research question.", { minLength: 1, maxLength: 2000 }),
+        mode: s.stringEnum("Research depth; defaults to deep.", ["deep", "max"]),
+        stream: s.boolean("Emit report text as synthesis events upstream; results are retrieved through get_research_run."),
+        output_language: s.string("BCP 47 report language."),
+        weak_sources_enabled: s.boolean("Allow relevant social and community sources."),
+        domain_type: s.stringEnum("Source pool.", ["web", "news", "research_paper"]),
+        after_date: s.string("Include results on or after this date.", { format: "date" }),
+        before_date: s.string("Include results on or before this date.", { format: "date" }),
+        recency_minutes: s.integer("Freshness window; cannot combine with date filters.", {
+            minimum: 1,
+            maximum: 5256000,
+        }),
+        domain_filter: s.object("Domain preferences.", {
+            mode: s.stringEnum("Prioritize domains or restrict results exclusively to them.", ["include", "exclusive"]),
+            domains: s.array("Domains to prefer or require.", s.string("Domain."), { maxItems: 150 }),
+            block: s.array("Domains to exclude.", s.string("Domain."), { maxItems: 150 }),
+        }, { required: ["mode"] }),
+        prior_run_id: s.string("Completed report and evidence to reuse; mutually exclusive with session_id."),
+        session_id: s.string("Research session to continue; mutually exclusive with prior_run_id.", {
+            format: "uuid",
+        }),
+    }, { required: ["query"] }),
+    not: {
+        anyOf: [
+            { required: ["prior_run_id", "session_id"] },
+            { required: ["recency_minutes", "after_date"] },
+            { required: ["recency_minutes", "before_date"] },
+        ],
+    },
+};
+export const researchListInput = s.object("Research filters and cursor.", {
+    status: researchStatus,
+    query: s.string("Case-insensitive partial query filter.", { maxLength: 500 }),
+    created_after: s.string("Created after timestamp.", { format: "date-time" }),
+    created_before: s.string("Created before timestamp.", { format: "date-time" }),
+    sort_direction: s.stringEnum("Creation time sort order; defaults to desc.", ["asc", "desc"]),
+    cursor: s.string("Pagination cursor; replay with the same sort_direction."),
+    limit: s.integer("Maximum returned records.", { minimum: 1, maximum: 100 }),
+}, { required: [] });
+export const researchOutput = s.looseObject("Research status, reports and evidence.", {
+    research_run_id: researchId,
+    status: researchStatus,
+    query: s.string("Research question."),
+    quick_result: s.nullable(s.looseObject("Quick answer, citations and optional progress.")),
+    quick_result_summary: s.nullable(s.string("Quick answer summary.")),
+    deep_result: s.nullable(s.looseObject("Final report.", {
+        result: s.string("Report text."),
+        citations: s.array("Cited sources.", s.string("Source URL.")),
+        freshness_report: s.looseObject("Source freshness information."),
+        termination_reason: s.string("Reason research stopped; synthesis_failed indicates interim findings."),
+    })),
+    run_ids: s.array("Spawned agent run identifiers.", s.string("Agent run identifier.")),
+    created_at: s.nullable(s.string("Creation timestamp.")),
+    completed_at: s.nullable(s.string("Completion timestamp.")),
+    error: s.nullable(s.looseObject("Saved terminal outcome, not an HTTP request error.")),
+    research_plan: s.nullable(s.looseObject("Subquestions and planned searches.")),
+    evidence: s.nullable(s.array("Sources and supported claims.", s.looseObject("Evidence source."))),
+    iterations: s.nullable(s.integer("Completed research iterations.", { minimum: 0 })),
+});

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

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

package/src/providers/tradebee/actions.js

@@ -0,0 +1,176 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const language = s.nonWhitespaceString("An enabled site language code returned by list_languages.");
+const id = {
+    type: ["integer", "string"],
+    description: "The resource ID, returned as an integer or string by Tradebee.",
+};
+const paginationInput = s.object("Pagination; omitted values default to page 1 and 5 items.", {
+    current_page: s.integer("Page number, starting at 1.", { minimum: 1 }),
+    page_size: s.integer("Items per page, from 1 to 10.", { minimum: 1, maximum: 10 }),
+}, { optional: ["current_page", "page_size"] });
+const paginationOutput = s.looseObject("Pagination returned by Tradebee; use next_page while has_next_page is true.", {
+    current_page: s.integer("The current page number."),
+    page_size: s.integer("The returned page size."),
+    total_page: s.integer("The total number of pages."),
+    total_count: s.integer("The total number of matching records."),
+    has_next_page: s.boolean("Whether another page is available."),
+    next_page: s.nullable(s.integer("The next page number, or null on the last page.")),
+});
+const commonFields = {
+    language: s.string("The site language code."),
+    tags: s.array("Resource keywords.", s.string("A keyword.")),
+    seo: s.looseObject("Search engine metadata.", {
+        title: s.string("The SEO title."),
+        description: s.string("The SEO description."),
+        keywords: s.string("Comma-separated SEO keywords."),
+    }),
+    create_time: s.string("The creation time as returned by Tradebee."),
+    update_time: s.string("The last update time as returned by Tradebee."),
+};
+const productFields = {
+    products_id: id,
+    ...commonFields,
+    group: s.looseObject("The product group.", {
+        productsgroup_id: id,
+        group_name: s.string("The group name."),
+    }),
+    product_name: s.string("The product name."),
+    model: s.string("The product model."),
+    images: s.array("Product image URLs.", s.string("An image URL.")),
+    attributes: s.array("Product attributes.", s.looseObject("A product attribute.", {
+        name: s.string("The attribute name."),
+        value: s.string("The attribute value."),
+    })),
+    brief_description: s.string("A short product description."),
+    description: s.string("The product HTML description."),
+    view_count: s.integer("The product view count."),
+    inquiry_count: s.integer("The product inquiry count."),
+    products_url: s.string("The product page URL."),
+};
+const productGroupFields = {
+    productsgroup_id: id,
+    ...commonFields,
+    group_name: s.string("The group name."),
+    productsgroup_url: s.string("The product group page URL."),
+    section: s.looseObject("HTML sections of the product group page.", {
+        top: s.string("The header HTML fragment."),
+        bottom: s.string("The footer HTML fragment."),
+    }),
+    is_leaf: s.boolean("Whether the group has no child groups."),
+    children: s.array("Recursive child groups, preserving provider-defined fields.", s.looseObject("A child product group.", {})),
+};
+const blogFields = {
+    blog_id: id,
+    ...commonFields,
+    group: s.looseObject("The blog group.", {
+        bloggroup_id: id,
+        group_name: s.string("The group name."),
+    }),
+    publisher: s.string("The publisher name."),
+    publication_date: s.string("The publication date as returned by Tradebee."),
+    title: s.string("The blog title."),
+    images: s.array("Blog cover image URLs.", s.string("An image URL.")),
+    summary: s.string("The blog summary."),
+    description: s.string("The blog HTML body."),
+    blog_url: s.string("The blog page URL."),
+};
+const blogGroupFields = {
+    bloggroup_id: id,
+    ...commonFields,
+    group_name: s.string("The group name."),
+    brief_description: s.string("A short blog group description."),
+    bloggroup_url: s.string("The blog group page URL."),
+};
+function fieldsInput(fields) {
+    return s.array("Return only these fields; omit to use the provider defaults.", s.stringEnum("A documented response field.", Object.keys(fields)));
+}
+export const tradebeeActions = [
+    defineProviderAction("tradebee", {
+        name: "list_languages",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List the enabled Tradebee site languages before querying products or blogs.",
+        inputSchema: s.requiredObject("No input parameters are required.", {}),
+        outputSchema: s.looseRequiredObject("Enabled site languages.", {
+            list: s.array("The enabled languages.", s.looseObject("An enabled language.", {
+                name: s.string("The language display name."),
+                language: s.string("The site language code."),
+            })),
+        }),
+    }),
+    defineProviderAction("tradebee", {
+        name: "list_products",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read Tradebee products in an enabled language, optionally by product or group. Filters are mutually exclusive. Follow pagination.next_page to continue.",
+        inputSchema: {
+            ...s.object("Product query.", {
+                language,
+                products_id: s.integer("Filter by product ID; cannot be combined with productsgroup_id."),
+                productsgroup_id: s.integer("Filter by product group ID; cannot be combined with products_id."),
+                fields: fieldsInput(productFields),
+                pagination: paginationInput,
+            }, { optional: ["products_id", "productsgroup_id", "fields", "pagination"] }),
+            not: { required: ["products_id", "productsgroup_id"] },
+        },
+        outputSchema: s.looseRequiredObject("A page of products with selected fields.", {
+            list: s.array("Products on this page.", s.looseObject("A product with the selected fields.", productFields)),
+            pagination: paginationOutput,
+        }),
+    }),
+    defineProviderAction("tradebee", {
+        name: "list_product_groups",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read Tradebee product groups and their children. Omit both filters for top-level groups, or select one group or parent. This endpoint is not paginated.",
+        inputSchema: {
+            ...s.object("Product group query.", {
+                language,
+                productsgroup_id: s.integer("Read one product group; cannot be combined with parent_productsgroup_id."),
+                parent_productsgroup_id: s.integer("Read children of this group; 0 selects top-level groups. Cannot be combined with productsgroup_id."),
+                fields: fieldsInput(productGroupFields),
+            }, { optional: ["productsgroup_id", "parent_productsgroup_id", "fields"] }),
+            not: { required: ["productsgroup_id", "parent_productsgroup_id"] },
+        },
+        outputSchema: s.looseRequiredObject("Product group hierarchy with selected fields.", {
+            list: s.array("Product groups.", s.looseObject("A product group with the selected fields.", productGroupFields)),
+        }),
+    }),
+    defineProviderAction("tradebee", {
+        name: "list_blogs",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read Tradebee blogs in an enabled language, optionally by blog or group. Filters are mutually exclusive. Follow pagination.next_page to continue.",
+        inputSchema: {
+            ...s.object("Blog query.", {
+                language,
+                blog_id: s.integer("Filter by blog ID; cannot be combined with bloggroup_id."),
+                bloggroup_id: s.integer("Filter by blog group ID; cannot be combined with blog_id."),
+                fields: fieldsInput(blogFields),
+                pagination: paginationInput,
+            }, { optional: ["blog_id", "bloggroup_id", "fields", "pagination"] }),
+            not: { required: ["blog_id", "bloggroup_id"] },
+        },
+        outputSchema: s.looseRequiredObject("A page of blogs with selected fields.", {
+            list: s.array("Blogs on this page.", s.looseObject("A blog with the selected fields.", blogFields)),
+            pagination: paginationOutput,
+        }),
+    }),
+    defineProviderAction("tradebee", {
+        name: "list_blog_groups",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read Tradebee blog groups in an enabled language, optionally selecting one group. Follow pagination.next_page to continue.",
+        inputSchema: s.object("Blog group query.", {
+            language,
+            bloggroup_id: s.integer("Read one blog group; omit to list all blog groups."),
+            fields: fieldsInput(blogGroupFields),
+            pagination: paginationInput,
+        }, { optional: ["bloggroup_id", "fields", "pagination"] }),
+        outputSchema: s.looseRequiredObject("A page of blog groups with selected fields.", {
+            list: s.array("Blog groups on this page.", s.looseObject("A blog group with the selected fields.", blogGroupFields)),
+            pagination: paginationOutput,
+        }),
+    }),
+];

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

@@ -0,0 +1,83 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { tradebeeActions } from "./actions.js";
+const baseUrl = "https://platform.tradew.com/openapis";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+const routes = {
+    list_languages: "/languages",
+    list_products: "/products/read",
+    list_product_groups: "/productsgroup/read",
+    list_blogs: "/blog/read",
+    list_blog_groups: "/bloggroup/read",
+};
+async function request({ route, body, apiKey, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "Tradebee" }, async (signal) => {
+        const response = await fetcher(`${baseUrl}${route}`, {
+            method: "POST",
+            signal,
+            headers: { ...defaultHeaders, authorization: `Bearer ${apiKey}` },
+            body: JSON.stringify(body),
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        const envelope = optionalRecord(payload);
+        if (!response.ok || envelope?.status !== true) {
+            const detail = optionalRawString(envelope?.msg) || `HTTP ${response.status}; invalid or unsuccessful response`;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Tradebee request failed: ${detail.split(apiKey).join("[REDACTED]")}`, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return requiredResponseRecord(envelope.data, "Tradebee response data");
+    });
+}
+const handlers = mapProviderActionHandlers("tradebee", tradebeeActions, (action) => async (dataInput, context) => {
+    const route = routes[action.name];
+    const body = dataInput;
+    if (["list_products", "list_blogs", "list_blog_groups"].includes(action.name)) {
+        const pagination = optionalRecord(body.pagination);
+        body.pagination = {
+            current_page: pagination?.current_page ?? 1,
+            page_size: pagination?.page_size ?? 5,
+        };
+    }
+    return request({
+        route: route,
+        body: body,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("tradebee", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request({
+            route: "/languages",
+            body: {},
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        return { profile: { displayName: "Tradebee API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "tradebee",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    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/trello/executors.js

@@ -1,3 +1,4 @@
+import { encodeRfc3986 } from "../../core/aws-sigv4.js";
 import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireCustomCredential, toProviderProxyError, } from "../provider-runtime.js";
 import { trelloActionHandlers, trelloApiBaseUrl, validateTrelloCredential } from "./runtime.js";
 const service = "trello";
@@ -23,9 +24,11 @@ export const proxy = async (input, context) => {
     try {
         const credential = await requireCustomCredential(context, service);
         const url = createProviderProxyUrl(trelloApiBaseUrl, input.endpoint, input.query);
-        url.searchParams.set("key", credential.values.apiKey);
-        url.searchParams.set("token", credential.values.apiToken);
+        url.searchParams.delete("key");
+        url.searchParams.delete("token");
         const headers = normalizeProviderProxyHeaders(input.headers);
+        // Trello attachment downloads require header authentication, unlike metadata reads.
+        headers.set("authorization", `OAuth oauth_consumer_key="${encodeRfc3986(credential.values.apiKey)}", oauth_token="${encodeRfc3986(credential.values.apiToken)}"`);
         headers.set("user-agent", providerUserAgent);
         const init = {
             method: input.method,

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

@@ -0,0 +1,17 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { twittrapiActionHandlers, twittrapiApiBaseUrl, validateTwittrapiCredential } from "./runtime.js";
+const service = "twittrapi";
+export const executors = defineApiKeyProviderExecutors(service, twittrapiActionHandlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: twittrapiApiBaseUrl,
+    auth: { type: "api_key_header", name: "x-api-key" },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateTwittrapiCredential(input.apiKey, fetcher, signal);
+    },
+};

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

@@ -0,0 +1,12 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ProviderActionHandlers } from "../provider-runtime.ts";
+import type { ApiKeyProviderContext, ProviderFetch, ProviderRuntimeHandler } from "../provider-runtime.ts";
+export declare const twittrapiApiBaseUrl = "https://api.twittrapi.com";
+type TwittrapiActionHandler = ProviderRuntimeHandler<ApiKeyProviderContext>;
+export declare const twittrapiActionHandlers: ProviderActionHandlers<"twittrapi", TwittrapiActionHandler>;
+/**
+ * Validate a TwittrAPI key against the free balance endpoint and report the
+ * account it belongs to.
+ */
+export declare function validateTwittrapiCredential(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
+export {};

package/src/providers/twittrapi/runtime.js

@@ -0,0 +1,203 @@
+import { optionalInteger, optionalRecord, optionalScalarString, optionalString, optionalStringArray, rawStringOrNull, } from "../../core/cast.js";
+import { encodePathSegment } from "../../core/request.js";
+import { parseProviderJsonBodyText, providerInputError, providerResponseError, providerUserAgent, ProviderRequestError, readProviderTextBody, requiredResponseRecord, runProviderRequest, setSearchParams, } from "../provider-runtime.js";
+export const twittrapiApiBaseUrl = "https://api.twittrapi.com";
+// The balance endpoint is free and identifies the key's account.
+const twittrapiValidationPath = "/balance";
+export const twittrapiActionHandlers = {
+    async search_tweets(input, context) {
+        const payload = await getTwittrapiJson({
+            path: "/search",
+            query: {
+                searchItem: optionalString(input.query),
+                category: optionalString(input.category),
+                ...pageQuery(input),
+            },
+        }, context);
+        return pageOutput(payload, "tweets");
+    },
+    async search_users(input, context) {
+        const payload = await getTwittrapiJson({
+            path: "/search",
+            query: { searchItem: optionalString(input.query), category: "People", ...pageQuery(input) },
+        }, context);
+        return pageOutput(payload, "users");
+    },
+    async get_tweet(input, context) {
+        const payload = await getTwittrapiJson({ path: `/simpletweet/${encodePathSegment(input.tweetId)}` }, context);
+        const tweet = readData(payload);
+        return { tweet: tweet === null ? null : requiredResponseRecord(tweet, "TwittrAPI tweet") };
+    },
+    async get_tweet_conversation(input, context) {
+        const payload = await getTwittrapiJson({
+            path: `/tweet/${encodePathSegment(input.tweetId)}`,
+            query: { rankingMode: optionalString(input.rankingMode), cursor: optionalString(input.cursor) },
+        }, context);
+        return pageOutput(payload, "tweets");
+    },
+    async get_tweet_quotes(input, context) {
+        const payload = await getTwittrapiJson({ path: `/tweet/${encodePathSegment(input.tweetId)}/quotes`, query: pageQuery(input) }, context);
+        return pageOutput(payload, "tweets");
+    },
+    async get_tweet_retweeters(input, context) {
+        const payload = await getTwittrapiJson({ path: `/tweet/${encodePathSegment(input.tweetId)}/retweets`, query: pageQuery(input) }, context);
+        return pageOutput(payload, "users");
+    },
+    async get_user(input, context) {
+        const userId = optionalString(input.userId);
+        const username = optionalString(input.username);
+        if (!userId && !username) {
+            throw providerInputError("userId or username is required.");
+        }
+        const path = userId
+            ? `/user/${encodePathSegment(userId)}`
+            : `/user/by/username/${encodePathSegment(stripHandlePrefix(username))}`;
+        const payload = await getTwittrapiJson({ path }, context);
+        const user = readData(payload);
+        return { user: user === null ? null : requiredResponseRecord(user, "TwittrAPI user") };
+    },
+    async get_users_by_ids(input, context) {
+        const payload = await getTwittrapiJson({ path: "/user/users/by/ids", query: { ids: optionalStringArray(input.userIds)?.join(",") } }, context);
+        return { users: readTwittrapiPage(payload).items };
+    },
+    async get_user_tweets(input, context) {
+        return pageOutput(await getUserCollection(input, "tweets", context), "tweets");
+    },
+    async get_user_tweets_and_replies(input, context) {
+        return pageOutput(await getUserCollection(input, "tweetsAndReplies", context), "tweets");
+    },
+    async get_user_followers(input, context) {
+        return pageOutput(await getUserCollection(input, "followers", context), "users");
+    },
+    async get_user_following(input, context) {
+        return pageOutput(await getUserCollection(input, "followings", context), "users");
+    },
+    async get_list_tweets(input, context) {
+        const payload = await getTwittrapiJson({ path: "/lists/tweets", query: { listId: optionalString(input.listId), ...pageQuery(input) } }, context);
+        return pageOutput(payload, "tweets");
+    },
+    async get_community_tweets(input, context) {
+        const payload = await getTwittrapiJson({ path: `/communities/${encodePathSegment(input.communityId)}/tweets`, query: pageQuery(input) }, context);
+        return pageOutput(payload, "tweets");
+    },
+    async get_trends(input, context) {
+        const woeid = optionalString(input.woeid) ?? "1";
+        const payload = await getTwittrapiJson({ path: `/trends/${encodePathSegment(woeid)}` }, context);
+        return { trends: readTwittrapiPage(payload).items };
+    },
+};
+/**
+ * Validate a TwittrAPI key against the free balance endpoint and report the
+ * account it belongs to.
+ */
+export async function validateTwittrapiCredential(apiKey, fetcher, signal) {
+    const payload = await getTwittrapiJson({ path: twittrapiValidationPath, simple: false }, { apiKey, fetcher, signal }, "validate");
+    const accountId = optionalScalarString(optionalRecord(payload)?.user_id);
+    return {
+        profile: {
+            accountId: accountId ?? "api_key",
+            displayName: "TwittrAPI API Key",
+        },
+        grantedScopes: [],
+        metadata: {
+            apiBaseUrl: twittrapiApiBaseUrl,
+            validationEndpoint: twittrapiValidationPath,
+        },
+    };
+}
+// Profile collections take a numeric user ID in the path. With only a handle,
+// the API expects -1 there and the handle in the username query parameter.
+async function getUserCollection(input, collection, context) {
+    const userId = optionalString(input.userId);
+    const username = optionalString(input.username);
+    if (!userId && !username) {
+        throw providerInputError("userId or username is required.");
+    }
+    return getTwittrapiJson({
+        path: `/user/${encodePathSegment(userId ?? "-1")}/${collection}`,
+        query: { username: userId ? undefined : stripHandlePrefix(username), ...pageQuery(input) },
+    }, context);
+}
+async function getTwittrapiJson(request, context, phase = "execute") {
+    const url = new URL(request.path, twittrapiApiBaseUrl);
+    setSearchParams(url, { ...request.query, format: request.simple === false ? undefined : "simple" });
+    return runProviderRequest({ signal: context.signal, label: "TwittrAPI" }, async (signal) => {
+        const response = await context.fetcher(url, {
+            method: "GET",
+            headers: {
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+                "x-api-key": context.apiKey,
+            },
+            signal,
+        });
+        const text = await readProviderTextBody(response, "TwittrAPI response", undefined, signal);
+        if (!response.ok) {
+            throw createTwittrapiError(response.status, parseErrorBody(text), phase);
+        }
+        return parseProviderJsonBodyText(text, {
+            emptyBody: null,
+            invalidJsonMessage: "TwittrAPI returned a response that is not valid JSON",
+        });
+    });
+}
+function parseErrorBody(text) {
+    return parseProviderJsonBodyText(text, {
+        emptyBody: null,
+        invalidJsonMessage: "TwittrAPI returned an error that is not valid JSON",
+        invalidJsonFallback: (raw) => raw.trim().slice(0, 500),
+    });
+}
+function createTwittrapiError(status, payload, phase) {
+    const message = optionalString(optionalRecord(payload)?.error) ??
+        (typeof payload === "string" ? optionalString(payload) : undefined) ??
+        `TwittrAPI request failed with status ${status}`;
+    // An invalid, unknown, or deactivated key should surface as a field error on
+    // the connect form rather than as a reconnect prompt.
+    if (phase === "validate" && (status === 401 || status === 404)) {
+        return new ProviderRequestError(400, message, payload);
+    }
+    if (status === 402) {
+        return new ProviderRequestError(402, message, payload, "insufficient_credit");
+    }
+    return new ProviderRequestError(status || 500, message, payload, status === 429 ? "rate_limited" : "provider_error");
+}
+function readData(payload) {
+    const record = requiredResponseRecord(payload, "TwittrAPI response");
+    if (!("data" in record)) {
+        throw providerResponseError("TwittrAPI response is missing data.");
+    }
+    return record.data;
+}
+function readTwittrapiPage(payload) {
+    const record = requiredResponseRecord(payload, "TwittrAPI response");
+    if (!Array.isArray(record.data)) {
+        throw providerResponseError("TwittrAPI response data must be an array.");
+    }
+    const nextCursor = rawStringOrNull(record.nextCursor);
+    return {
+        nextCursor,
+        previousCursor: rawStringOrNull(record.previousCursor),
+        hasNextPage: typeof record.hasNextPage === "boolean" ? record.hasNextPage : nextCursor !== null,
+        items: record.data.map((item) => requiredResponseRecord(item, "TwittrAPI response item")),
+    };
+}
+function pageOutput(payload, itemField) {
+    const page = readTwittrapiPage(payload);
+    return {
+        [itemField]: page.items,
+        nextCursor: page.nextCursor,
+        previousCursor: page.previousCursor,
+        hasNextPage: page.hasNextPage,
+    };
+}
+function pageQuery(input) {
+    const count = optionalInteger(input.count);
+    return {
+        count: count === undefined ? undefined : String(count),
+        cursor: optionalString(input.cursor),
+    };
+}
+function stripHandlePrefix(username) {
+    return username.startsWith("@") ? username.slice(1) : username;
+}

package/src/providers/typeform/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 executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/typeform/executors.js

@@ -1,5 +1,6 @@
 import { defineBearerProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { fetchTypeformCurrentAccount, typeformActionHandlers, typeformApiBaseUrl, validateTypeformCredential, } from "./runtime.js";
+import { typeformResponse } from "./trigger-on-form-response.js";
 const service = "typeform";
 export const executors = defineBearerProviderExecutors(service, typeformActionHandlers);
 export const proxy = defineProviderProxy({
@@ -15,3 +16,4 @@ export const credentialValidators = {
         return fetchTypeformCurrentAccount(input.accessToken, fetcher, signal);
     },
 };
+export const triggers = [typeformResponse];

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

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

package/src/providers/typeform/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";
+};