@oomol-lab/open-connector 1.6.1 → 1.6.3

package/src/providers/templatedocs/runtime.js

@@ -0,0 +1,151 @@
+import { basename } from "node:path";
+import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
+import { readBoundedResponseBytes } from "../../core/request.js";
+import { providerInputError, ProviderRequestError, providerUserAgent, readProviderJsonBody, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
+export const templatedocsApiBaseUrl = "https://templatedocs.io/api";
+export const templatedocsActionHandlers = {
+    list_templates(input, context) {
+        const pageIndex = optionalInteger(input.pageIndex);
+        return requestTemplateDocsJson({
+            ...context,
+            path: `/v1/templates${pageIndex == null ? "" : `?pageIndex=${pageIndex}`}`,
+        });
+    },
+    get_template(input, context) {
+        return requestTemplateDocsJson({ ...context, path: templatePath(input.templateId) });
+    },
+    async update_template(input, context) {
+        const name = optionalString(input.name)?.trim();
+        const allowGenerationWithWarnings = input.allowGenerationWithWarnings;
+        if (!name && allowGenerationWithWarnings == null) {
+            throw providerInputError("name or allowGenerationWithWarnings is required");
+        }
+        await requestTemplateDocs({
+            ...context,
+            path: templatePath(input.templateId),
+            method: "PATCH",
+            body: compactObject({
+                name,
+                options: allowGenerationWithWarnings == null ? undefined : { allowGenerationWithWarnings },
+            }),
+        });
+        return { success: true };
+    },
+    async delete_template(input, context) {
+        await requestTemplateDocs({
+            ...context,
+            path: templatePath(input.templateId),
+            method: "DELETE",
+        });
+        return { success: true };
+    },
+    generate_document: generateDocument,
+};
+export async function validateTemplateDocsCredential(apiKey, fetcher, signal) {
+    const payload = await requestTemplateDocsJson({
+        apiKey,
+        fetcher,
+        signal,
+        path: "/v1/templates?pageIndex=1",
+    });
+    const record = optionalRecord(payload);
+    return {
+        profile: { displayName: "TemplateDocs API Key" },
+        grantedScopes: [],
+        metadata: compactObject({
+            apiBaseUrl: templatedocsApiBaseUrl,
+            validationEndpoint: "/v1/templates",
+            pageSize: optionalInteger(record?.pageSize),
+        }),
+    };
+}
+async function generateDocument(input, context) {
+    if (!context.transitFiles)
+        throw providerInputError("Transit file storage is not enabled.");
+    const format = optionalString(input.format) ?? "docx";
+    const response = await requestTemplateDocs({
+        ...context,
+        path: `${templatePath(input.templateId)}/generate`,
+        method: "POST",
+        body: {
+            data: optionalRecord(input.data) ?? {},
+            output: compactObject({
+                format,
+                filename: optionalString(input.filename)?.trim(),
+                email: optionalRecord(input.email),
+            }),
+        },
+    });
+    const name = generatedFileName(input.filename, format);
+    const mimeType = response.headers.get("content-type")?.split(";")[0]?.trim() ?? mimeTypeForFormat(format);
+    const bytes = await readBoundedResponseBytes(response, {
+        maxBytes: context.transitFiles.maxBytes,
+        fieldName: name,
+        createError: (message) => new ProviderRequestError(413, message),
+    });
+    if (bytes.byteLength === 0)
+        throw new ProviderRequestError(502, "TemplateDocs returned an empty document");
+    const stored = await context.transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
+    return {
+        document: {
+            name: stored.name,
+            mimeType: stored.mimeType,
+            downloadUrl: stored.downloadUrl,
+            sizeBytes: stored.sizeBytes,
+        },
+    };
+}
+async function requestTemplateDocsJson(input) {
+    const response = await requestTemplateDocs(input);
+    return readProviderJsonBody(response, {
+        emptyBody: undefined,
+        invalidJsonMessage: "TemplateDocs returned invalid JSON",
+    });
+}
+async function requestTemplateDocs(input) {
+    return runProviderRequest({ label: "TemplateDocs", signal: input.signal }, async (signal) => {
+        const headers = new Headers({
+            accept: "application/json",
+            authorization: `Bearer ${input.apiKey}`,
+            "user-agent": providerUserAgent,
+        });
+        if (input.body != null)
+            headers.set("content-type", "application/json");
+        const response = await input.fetcher(`${templatedocsApiBaseUrl}${input.path}`, {
+            method: input.method ?? "GET",
+            headers,
+            body: input.body == null ? undefined : JSON.stringify(input.body),
+            signal,
+        });
+        if (!response.ok)
+            throw await createTemplateDocsError(response);
+        return response;
+    });
+}
+async function createTemplateDocsError(response) {
+    let message = `TemplateDocs request failed with status ${response.status}`;
+    try {
+        const payload = optionalRecord(await readProviderJsonBody(response, {
+            emptyBody: undefined,
+            invalidJsonMessage: "TemplateDocs returned invalid JSON",
+        }));
+        message = optionalString(optionalRecord(payload?.error)?.message) ?? message;
+    }
+    catch { }
+    return new ProviderRequestError(response.status || 502, message);
+}
+function templatePath(value) {
+    return `/v1/templates/${encodeURIComponent(requiredInputString(value, "templateId"))}`;
+}
+function generatedFileName(value, format) {
+    const requested = optionalString(value)?.trim();
+    if (!requested)
+        return `templatedocs-document.${format}`;
+    const safeName = basename(requested.replaceAll("\\", "/"));
+    return safeName.toLowerCase().endsWith(`.${format}`) ? safeName : `${safeName}.${format}`;
+}
+function mimeTypeForFormat(format) {
+    return format === "pdf"
+        ? "application/pdf"
+        : "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+}

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

@@ -0,0 +1,15 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { terminusAppActionHandlers, validateTerminusAppCredential } from "./runtime.js";
+const service = "terminus_app";
+export const executors = defineApiKeyProviderExecutors(service, terminusAppActionHandlers);
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: "https://api.terminusapp.com",
+    auth: { type: "api_key_basic", suffix: ":" },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateTerminusAppCredential(input.apiKey, fetcher, signal);
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+export declare const terminusAppApiBaseUrl = "https://api.terminusapp.com";
+type Handler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
+export declare const terminusAppActionHandlers: ProviderActionHandlers<"terminus_app", Handler>;
+export declare function validateTerminusAppCredential(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
+export {};

package/src/providers/terminus_app/runtime.js

@@ -0,0 +1,172 @@
+import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString, recordOrEmpty, } from "../../core/cast.js";
+import { readProviderTextBody } from "../provider-runtime.js";
+import { basicAuthorizationHeader, providerUserAgent, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const terminusAppApiBaseUrl = "https://api.terminusapp.com";
+export const terminusAppActionHandlers = {
+    async list_projects(input, context) {
+        return normalizeList(await requestTerminusApp({
+            ...context,
+            path: "/v1/projects/",
+            phase: "execute",
+            query: buildPaginationQuery(input),
+        }), "projects");
+    },
+    async list_conventions(input, context) {
+        const projectId = requiredInputString(input.projectId, "projectId");
+        return normalizeList(await requestTerminusApp({
+            ...context,
+            path: `/v1/projects/${encodeURIComponent(projectId)}/conventions`,
+            phase: "execute",
+            query: buildPaginationQuery(input),
+        }), "conventions");
+    },
+    async get_convention(input, context) {
+        const projectId = requiredInputString(input.projectId, "projectId");
+        const payload = await requestTerminusApp({
+            ...context,
+            path: `/v1/projects/${encodeURIComponent(projectId)}/conventions/${optionalInteger(input.conventionId)}`,
+            phase: "execute",
+        });
+        return { convention: requiredResponseRecord(payload, "Terminus convention response") };
+    },
+    async list_links(input, context) {
+        const projectId = requiredInputString(input.projectId, "projectId");
+        const payload = await requestTerminusApp({
+            ...context,
+            path: `/v1/projects/${encodeURIComponent(projectId)}/links`,
+            phase: "execute",
+            query: {
+                ...buildPaginationQuery(input),
+                "created_at[gt]": stringifyInteger(optionalInteger(input.createdAfter)),
+                "updated_at[gt]": stringifyInteger(optionalInteger(input.updatedAfter)),
+            },
+        });
+        return normalizeList(payload, "links");
+    },
+    async create_link(input, context) {
+        const projectId = requiredInputString(input.projectId, "projectId");
+        const payload = await requestTerminusApp({
+            ...context,
+            method: "POST",
+            path: `/v1/projects/${encodeURIComponent(projectId)}/links`,
+            phase: "execute",
+            body: buildCreateLinkBody(input),
+        });
+        return { link: requiredResponseRecord(payload, "Terminus link response") };
+    },
+};
+export async function validateTerminusAppCredential(apiKey, fetcher, signal) {
+    const payload = await requestTerminusApp({
+        apiKey,
+        fetcher,
+        signal,
+        path: "/v1/projects/",
+        phase: "validate",
+        query: { items: "1" },
+    });
+    normalizeList(payload, "projects");
+    return {
+        profile: { accountId: "terminus-app", displayName: "Terminus App API Key" },
+        grantedScopes: [],
+        metadata: { apiBaseUrl: terminusAppApiBaseUrl, validationEndpoint: "/v1/projects/" },
+    };
+}
+function buildPaginationQuery(input) {
+    return { page: stringifyInteger(optionalInteger(input.page)), items: stringifyInteger(optionalInteger(input.items)) };
+}
+function stringifyInteger(value) {
+    return value === undefined ? undefined : String(value);
+}
+function buildCreateLinkBody(input) {
+    const convention = optionalRecord(input.convention);
+    const inputFields = Array.isArray(convention?.inputFields)
+        ? convention.inputFields.map((value) => {
+            const field = recordOrEmpty(value);
+            return { field_id: optionalInteger(field.fieldId), input_value: optionalString(field.inputValue) };
+        })
+        : undefined;
+    const utm = optionalRecord(input.utm);
+    return compactObject({
+        url: requiredInputString(input.url, "url"),
+        convention: convention ? { id: optionalInteger(convention.id), input_fields: inputFields } : undefined,
+        utm: utm ? mapTagObject(utm) : undefined,
+        custom: mapOptionalNamedTags(input.custom),
+        info: mapOptionalNamedTags(input.info),
+        label_names: Array.isArray(input.labelNames) ? input.labelNames : undefined,
+        description: optionalString(input.description),
+        skip_monitoring: optionalBoolean(input.skipMonitoring),
+        short_url_key: optionalString(input.shortUrlKey),
+        skip_url_validation: optionalBoolean(input.skipUrlValidation),
+    });
+}
+function mapTagObject(input) {
+    return compactObject({
+        campaign: optionalRecord(input.campaign),
+        medium: optionalRecord(input.medium),
+        source: optionalRecord(input.source),
+        content: optionalRecord(input.content),
+        term: optionalRecord(input.term),
+    });
+}
+function mapOptionalNamedTags(value) {
+    const record = optionalRecord(value);
+    return record ? Object.fromEntries(Object.entries(record)) : undefined;
+}
+async function requestTerminusApp(input) {
+    return runProviderRequest({ label: "Terminus App", signal: input.signal }, async (signal) => {
+        const url = new URL(input.path, terminusAppApiBaseUrl);
+        for (const [name, value] of Object.entries(input.query ?? {}))
+            if (value !== undefined)
+                url.searchParams.set(name, value);
+        const response = await input.fetcher(url, {
+            method: input.method ?? "GET",
+            headers: {
+                accept: "application/json",
+                authorization: basicAuthorizationHeader(`${input.apiKey}:`),
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: input.body === undefined ? undefined : JSON.stringify(input.body),
+            signal,
+        });
+        const payload = await readPayload(response);
+        if (!response.ok)
+            throw createError(response.status, payload, input.phase);
+        return payload;
+    });
+}
+async function readPayload(response) {
+    const text = await readProviderTextBody(response, "Terminus App response");
+    if (!text.trim())
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new ProviderRequestError(502, "Terminus App returned invalid JSON");
+    }
+}
+function createError(status, payload, phase) {
+    const message = extractErrorMessage(payload) ?? `Terminus App request failed with status ${status}`;
+    if (status === 429)
+        return new ProviderRequestError(429, message, payload);
+    if (status === 401)
+        return new ProviderRequestError(phase === "validate" ? 400 : 401, message, payload);
+    return new ProviderRequestError(status || 502, message, payload);
+}
+function extractErrorMessage(payload) {
+    const record = optionalRecord(payload);
+    return optionalString(record?.message) ?? optionalString(record?.error) ?? optionalString(record?.detail);
+}
+function normalizeList(payload, outputName) {
+    const record = requiredResponseRecord(payload, "Terminus list response");
+    return {
+        [outputName]: requireArray(record.data, "Terminus list response data"),
+        meta: requiredResponseRecord(record.meta, "Terminus list response meta"),
+    };
+}
+function requireArray(value, label) {
+    if (Array.isArray(value))
+        return value;
+    throw new ProviderRequestError(502, `${label} must be an array`);
+}

package/src/providers/the_official_board/actions.js

@@ -12,6 +12,7 @@ const resultObjectSchema = s.requiredObject("An object response returned by The
 export const theOfficialBoardActions = [
     defineProviderAction(service, {
         name: "search_companies",
+        operationType: "read",
         description: "Find company organizational chart identifiers by company name.",
         inputSchema: s.object("Parameters for searching companies.", {
             companyName: nonEmptyString("The full or partial company name to search for."),
@@ -24,6 +25,7 @@ export const theOfficialBoardActions = [
     }),
     defineProviderAction(service, {
         name: "get_company_org_chart",
+        operationType: "read",
         description: "Retrieve a company organizational chart and its executives in structured JSON.",
         inputSchema: s.requiredObject("Parameters for retrieving a company organizational chart.", {
             id: nonEmptyString("The company unique identifier returned by search_companies."),
@@ -32,6 +34,7 @@ export const theOfficialBoardActions = [
     }),
     defineProviderAction(service, {
         name: "search_executives",
+        operationType: "read",
         description: "Search executives by first name, last name, or full name.",
         inputSchema: s.object("Parameters for searching executives.", {
             name: nonEmptyString("The executive first name, last name, or full name to search for."),
@@ -44,6 +47,7 @@ export const theOfficialBoardActions = [
     }),
     defineProviderAction(service, {
         name: "find_executive",
+        operationType: "read",
         description: "Find executives by an exact email address or LinkedIn profile URL.",
         inputSchema: s.object("Parameters for finding an executive by an exact identifier.", {
             email: s.string("The executive email address to match.", { format: "email" }),
@@ -53,6 +57,7 @@ export const theOfficialBoardActions = [
     }),
     defineProviderAction(service, {
         name: "get_executive_biography",
+        operationType: "read",
         description: "Retrieve detailed biography information for an executive.",
         inputSchema: s.requiredObject("Parameters for retrieving an executive biography.", {
             bioId: nonEmptyString("The executive biography identifier returned by an executive search."),
@@ -61,6 +66,7 @@ export const theOfficialBoardActions = [
     }),
     defineProviderAction(service, {
         name: "list_direct_colleagues",
+        operationType: "read",
         description: "List the direct colleagues in an executive's organizational environment.",
         inputSchema: s.requiredObject("Parameters for listing an executive's direct colleagues.", {
             bioId: nonEmptyString("The executive biography identifier returned by an executive search."),
@@ -69,6 +75,7 @@ export const theOfficialBoardActions = [
     }),
     defineProviderAction(service, {
         name: "list_recent_org_chart_news",
+        operationType: "read",
         description: "List the main organizational chart changes for a company from the past 12 months.",
         inputSchema: s.requiredObject("Parameters for listing recent organizational chart news.", {
             id: nonEmptyString("The company unique identifier returned by search_companies."),
@@ -77,6 +84,7 @@ export const theOfficialBoardActions = [
     }),
     defineProviderAction(service, {
         name: "list_watchlist_changes",
+        operationType: "read",
         description: "List recently modified organizational charts from the connected user's watchlist.",
         inputSchema: s.object("Pagination parameters for watchlist changes.", {
             amount: s.integer("The number of changes to return.", { minimum: 1 }),

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

@@ -0,0 +1,15 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { ticketTailorActionHandlers, validateTicketTailorCredential } from "./runtime.js";
+const service = "ticket_tailor";
+export const executors = defineApiKeyProviderExecutors(service, ticketTailorActionHandlers);
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: "https://api.tickettailor.com",
+    auth: { type: "api_key_basic", suffix: ":" },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    apiKey(input, { fetcher, signal }) {
+        return validateTicketTailorCredential(input.apiKey, fetcher, signal);
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+export declare const ticketTailorApiBaseUrl = "https://api.tickettailor.com";
+type Handler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
+export declare const ticketTailorActionHandlers: ProviderActionHandlers<"ticket_tailor", Handler>;
+export declare function validateTicketTailorCredential(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
+export {};

package/src/providers/ticket_tailor/runtime.js

@@ -0,0 +1,152 @@
+import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
+import { readProviderTextBody } from "../provider-runtime.js";
+import { basicAuthorizationHeader, providerUserAgent, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const ticketTailorApiBaseUrl = "https://api.tickettailor.com";
+const ticketTailorApiKeyHelpUrl = "https://help.tickettailor.com/en/articles/4593218-how-do-i-connect-to-the-ticket-tailor-api";
+const paginationFields = ["starting_after", "ending_before", "limit"];
+const actionRoutes = {
+    list_events: {
+        collectionPath: "/v1/events",
+        queryFields: [
+            ...paginationFields,
+            "start_at",
+            "start_at.gt",
+            "start_at.gte",
+            "start_at.lt",
+            "start_at.lte",
+            "end_at",
+            "end_at.gt",
+            "end_at.gte",
+            "end_at.lt",
+            "end_at.lte",
+            "status",
+            "name",
+            "venue",
+        ],
+    },
+    get_event: { collectionPath: "/v1/events", idField: "event_id" },
+    list_orders: {
+        collectionPath: "/v1/orders",
+        queryFields: [
+            ...paginationFields,
+            "created_at",
+            "created_at.gt",
+            "created_at.gte",
+            "created_at.lt",
+            "created_at.lte",
+            "name",
+            "email",
+            "txn_id",
+            "barcode",
+            "event_id",
+            "event_series_id",
+            "status",
+            "store_id",
+            "referral_tag",
+        ],
+    },
+    get_order: { collectionPath: "/v1/orders", idField: "order_id" },
+    list_issued_tickets: {
+        collectionPath: "/v1/issued_tickets",
+        queryFields: [
+            ...paginationFields,
+            "event_id",
+            "event_series_id",
+            "order_id",
+            "barcode",
+            "name",
+            "email",
+            "reference",
+            "status",
+            "created_at",
+            "created_at.gt",
+            "created_at.gte",
+            "created_at.lt",
+            "created_at.lte",
+        ],
+    },
+    get_issued_ticket: { collectionPath: "/v1/issued_tickets", idField: "issued_ticket_id" },
+};
+function createHandler(route) {
+    return async (input, context) => {
+        const path = route.idField
+            ? `${route.collectionPath}/${encodeURIComponent(requiredInputString(input[route.idField], route.idField))}`
+            : route.collectionPath;
+        const payload = await requestTicketTailorJson({
+            apiKey: context.apiKey,
+            path,
+            query: route.idField ? undefined : buildListQuery(input, route.queryFields ?? []),
+            fetcher: context.fetcher,
+            signal: context.signal,
+        });
+        if (route.idField)
+            return requiredResponseRecord(payload, "Ticket Tailor resource response");
+        const response = requiredResponseRecord(payload, "Ticket Tailor list response");
+        return { ...response, data: requireArray(response.data, "Ticket Tailor list response data") };
+    };
+}
+export const ticketTailorActionHandlers = Object.fromEntries(Object.entries(actionRoutes).map(([name, route]) => [name, createHandler(route)]));
+export async function validateTicketTailorCredential(apiKey, fetcher, signal) {
+    await requestTicketTailorJson({ apiKey, path: "/v1/ping", fetcher, signal });
+    return {
+        profile: { accountId: "ticket-tailor", displayName: "Ticket Tailor Box Office" },
+        grantedScopes: [],
+        metadata: {
+            apiBaseUrl: ticketTailorApiBaseUrl,
+            validationEndpoint: "/v1/ping",
+            credentialHelpUrl: ticketTailorApiKeyHelpUrl,
+        },
+    };
+}
+function buildListQuery(input, fields) {
+    const query = {};
+    for (const field of fields)
+        query[field] =
+            field === "limit" || field.includes("_at") ? optionalInteger(input[field]) : optionalString(input[field]);
+    return compactObject(query);
+}
+async function requestTicketTailorJson(input) {
+    return runProviderRequest({ label: "Ticket Tailor", signal: input.signal }, async (signal) => {
+        const url = new URL(input.path, ticketTailorApiBaseUrl);
+        for (const [key, value] of Object.entries(input.query ?? {}))
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        const response = await input.fetcher(url, {
+            method: "GET",
+            headers: {
+                accept: "application/json",
+                authorization: basicAuthorizationHeader(`${input.apiKey}:`),
+                "user-agent": providerUserAgent,
+            },
+            signal,
+        });
+        const payload = await readPayload(response);
+        if (!response.ok)
+            throw createError(response, payload);
+        return payload;
+    });
+}
+async function readPayload(response) {
+    const text = await readProviderTextBody(response, "Ticket Tailor response");
+    if (!text.trim())
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new ProviderRequestError(502, "Ticket Tailor returned invalid JSON");
+    }
+}
+function createError(response, payload) {
+    const record = optionalRecord(payload) ?? {};
+    const upstreamMessage = optionalString(record.message) ??
+        optionalString(record.error) ??
+        `Ticket Tailor request failed with HTTP ${response.status}`;
+    const code = optionalString(record.error_code);
+    return new ProviderRequestError(response.status || 502, code ? `[${code}] ${upstreamMessage}` : upstreamMessage, payload, code);
+}
+function requireArray(value, label) {
+    if (Array.isArray(value))
+        return value;
+    throw new ProviderRequestError(502, `${label} must be an array`);
+}

package/src/providers/tinypng/actions.js

@@ -58,6 +58,7 @@ const outputImageInputSchema = s.object("The input payload for retrieving a Tiny
 export const tinypngActions = [
     defineProviderAction(service, {
         name: "shrink_image",
+        operationType: "write",
         description: "Create a TinyPNG compressed image resource from a public URL or base64-encoded image bytes.",
         requiredScopes: [],
         inputSchema: shrinkImageInputSchema,
@@ -77,6 +78,7 @@ export const tinypngActions = [
     }),
     defineProviderAction(service, {
         name: "output_image",
+        operationType: "read",
         description: "Transform a TinyPNG output image and return a transit URL for the resulting file.",
         requiredScopes: [],
         inputSchema: outputImageInputSchema,

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

@@ -1,3 +1,4 @@
 import type { ActionDefinition } from "../../core/types.ts";
 export declare const tongdaxinReadOnlyToolNames: string[];
+export type TongdaxinReadOnlyToolName = (typeof tongdaxinReadOnlyToolNames)[number];
 export declare const tongdaxinActions: ActionDefinition[];