@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/smooth/actions.js

@@ -0,0 +1,138 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const taskId = s.nonEmptyString("Task ID returned by submit_task.");
+const profileId = s.nonEmptyString("Browser profile ID.");
+const taskOutput = {
+    ...s.looseObject("Task status, result and upstream metadata.", {
+        id: taskId,
+        status: s.string("Task state: waiting, running, done, failed or cancelled."),
+        output: s.unknown("Task output, optionally matching response_model."),
+        credits_used: s.nullable(s.integer("Credits used by the task.")),
+        device: s.nullable(s.string("Browser device type.")),
+        live_url: s.nullable(s.string("URL for live browser access.")),
+        recording_url: s.nullable(s.string("URL for the task recording.")),
+        downloads_url: s.nullable(s.string("URL for downloaded files.")),
+        created_at: s.nullable(s.integer("Task creation Unix timestamp.")),
+        events: s.nullable(s.array("New task events.", s.looseObject("Upstream event payload."))),
+    }),
+    required: ["id", "status"],
+};
+const profileOutput = s.looseRequiredObject("Browser profile.", { id: profileId });
+const success = s.requiredObject("Operation result.", {
+    success: s.boolean("Whether the operation succeeded."),
+});
+const taskOptions = {
+    response_model: s.nullable(s.looseObject("JSON Schema for the desired task output.")),
+    url: s.nullable(s.string("Starting URL visited by Smooth.", { format: "uri" })),
+    metadata: s.nullable({
+        ...s.record("Agent variables; at most 16 keys and 2048 characters per string value.", s.anyOf("Variable value.", [
+            s.string("Text value.", { maxLength: 2048 }),
+            s.number("Numeric value."),
+            s.boolean("Boolean value."),
+        ])),
+        maxProperties: 16,
+    }),
+    files: s.nullable(s.array("Previously uploaded file IDs.", s.string("File ID."))),
+    agent: s.stringEnum("Agent model; defaults to smooth.", ["smooth", "smooth-lite"]),
+    max_steps: s.integer("Maximum agent steps; defaults to 32.", { minimum: 2, maximum: 128 }),
+    device: s.stringEnum("Browser device; defaults to desktop.", ["desktop", "mobile", "desktop-lg"]),
+    allowed_urls: s.nullable(s.array("Allowed URL glob patterns; omitted means unrestricted.", s.string("URL glob pattern, such as https://**.example.com/**."))),
+    enable_recording: s.boolean("Record the task; defaults to true."),
+    profile_id: s.nullable(profileId),
+    profile_read_only: s.boolean("Do not save browser changes to the profile; defaults to false."),
+    stealth_mode: s.boolean("Enable stealth mode; defaults to false."),
+    proxy_server: s.nullable(s.string("Remote proxy URL. Local self tunnels require a separate Smooth client.")),
+    proxy_username: s.nullable(s.string("Proxy authentication username.")),
+    proxy_password: s.nullable(s.string("Proxy authentication password.")),
+    certificates: s.nullable(s.array("Client certificates for secure websites.", s.object("Client certificate.", {
+        file: s.string("Base64-encoded p12 certificate."),
+        password: s.nullable(s.string("Certificate password.")),
+    }, { optional: ["password"] }))),
+    use_adblock: s.nullable(s.boolean("Enable ad blocking; defaults to true.")),
+    additional_tools: s.nullable(s.record("Built-in tool configurations, such as screenshot, hover or print_page.", s.nullable(s.looseObject("Tool configuration, or null for defaults.")))),
+    experimental_features: s.nullable(s.looseObject("Upstream experimental feature configuration.")),
+    extensions: s.nullable(s.array("Previously uploaded browser extension IDs.", s.string("Extension ID."))),
+    show_cursor: s.boolean("Show the mouse cursor; defaults to false."),
+};
+export const smoothActions = [
+    defineProviderAction("smooth", {
+        name: "submit_task",
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Submit a natural-language browser task to Smooth. The task may modify or delete data on visited sites. Uses account credits; returns immediately for result polling.",
+        asyncLifecycle: {
+            startActionId: "smooth.submit_task",
+            statusActionId: "smooth.get_task",
+            cancelActionId: "smooth.cancel_task",
+        },
+        inputSchema: s.object("One-shot browser task parameters.", {
+            task: s.nonEmptyString("Natural-language task to execute. Interactive sessions and custom tool callbacks are not supported by this action."),
+            ...taskOptions,
+        }, { optional: Object.keys(taskOptions) }),
+        outputSchema: taskOutput,
+    }),
+    defineProviderAction("smooth", {
+        name: "get_task",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get task status and results, including optional download URLs and events after a timestamp.",
+        asyncLifecycle: {
+            startActionId: "smooth.submit_task",
+            statusActionId: "smooth.get_task",
+            cancelActionId: "smooth.cancel_task",
+        },
+        inputSchema: s.object("Task lookup parameters.", {
+            task_id: taskId,
+            event_t: s.integer("Return events after this timestamp; defaults to zero."),
+            downloads: s.boolean("Include the download URL; defaults to false."),
+        }, { optional: ["event_t", "downloads"] }),
+        outputSchema: taskOutput,
+    }),
+    defineProviderAction("smooth", {
+        name: "list_tasks",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List tasks, optionally paging to tasks created before a timestamp.",
+        inputSchema: s.object("Task list parameters.", {
+            t: s.integer("Return tasks created before this timestamp."),
+            l: s.integer("Result limit; defaults to 32.", { minimum: 1, maximum: 128 }),
+        }, { optional: ["t", "l"] }),
+        outputSchema: s.requiredObject("Task list.", {
+            tasks: s.array("Tasks in upstream order.", taskOutput),
+        }),
+    }),
+    defineProviderAction("smooth", {
+        name: "cancel_task",
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Cancel a running Smooth task.",
+        inputSchema: s.requiredObject("Task to cancel.", { task_id: taskId }),
+        outputSchema: success,
+    }),
+    defineProviderAction("smooth", {
+        name: "list_profiles",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List reusable browser profiles.",
+        inputSchema: s.requiredObject("Profile list parameters.", {}),
+        outputSchema: s.requiredObject("Profile list.", {
+            profiles: s.array("Browser profiles.", profileOutput),
+        }),
+    }),
+    defineProviderAction("smooth", {
+        name: "create_profile",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Create a browser profile to persist cookies and authentication across tasks.",
+        inputSchema: s.object("Profile creation parameters.", { id: s.nullable(profileId) }, { optional: ["id"] }),
+        outputSchema: profileOutput,
+    }),
+    defineProviderAction("smooth", {
+        name: "delete_profile",
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Delete a browser profile and its persisted browser state.",
+        inputSchema: s.requiredObject("Profile to delete.", { profile_id: profileId }),
+        outputSchema: success,
+    }),
+];

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

@@ -0,0 +1,102 @@
+import { optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, isAbortLikeError, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { smoothActions } from "./actions.js";
+const baseUrl = "https://api.smooth.sh/api/v1";
+const defaultHeaders = { accept: "application/json" };
+async function request({ url, method, apiKey, body, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "Smooth" }, async (signal) => {
+        const response = await fetcher(url.toString(), {
+            method,
+            headers: { ...defaultHeaders, apikey: apiKey, "content-type": "application/json" },
+            body: body ? JSON.stringify(body) : undefined,
+            signal,
+        });
+        let payload;
+        try {
+            payload = requiredResponseRecord(await response.json(), "Smooth response");
+        }
+        catch (error) {
+            if (isAbortLikeError(error))
+                throw error;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, "Smooth returned an invalid JSON response", undefined, "provider_error");
+        }
+        if (!response.ok) {
+            const detail = optionalRawString(payload.detail);
+            throw new ProviderRequestError(response.status, `Smooth request failed${detail ? `: ${detail.split(apiKey).join("[REDACTED]")}` : ""}`, undefined, "provider_error");
+        }
+        return payload.r;
+    });
+}
+const handlers = mapProviderActionHandlers("smooth", smoothActions, (action) => async (dataInput, context) => {
+    const values = dataInput;
+    const url = new URL(`${baseUrl}/${action.name.endsWith("profile") || action.name.endsWith("profiles") ? "profile" : "task"}`);
+    const id = values.task_id ?? values.profile_id;
+    if (action.name === "get_task" || action.name === "cancel_task" || action.name === "delete_profile") {
+        const segment = String(id);
+        if (segment === "." || segment === "..")
+            throw new ProviderRequestError(400, "Resource ID must not be a dot segment", undefined, "invalid_input");
+        url.pathname += `/${encodeURIComponent(segment)}`;
+    }
+    const method = action.name === "submit_task" || action.name === "create_profile"
+        ? "POST"
+        : action.name === "cancel_task" || action.name === "delete_profile"
+            ? "DELETE"
+            : "GET";
+    if (action.name === "get_task" || action.name === "list_tasks") {
+        for (const key of action.name === "get_task" ? ["event_t", "downloads"] : ["t", "l"]) {
+            if (values[key] !== undefined)
+                url.searchParams.set(key, String(values[key]));
+        }
+    }
+    const result = await request({
+        url: url,
+        method: method,
+        apiKey: context.apiKey,
+        body: method === "POST" ? values : undefined,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+    if (action.name === "list_tasks" || action.name === "list_profiles") {
+        if (!Array.isArray(result))
+            throw new ProviderRequestError(502, "Smooth returned an invalid list", undefined, "provider_error");
+        return action.name === "list_tasks" ? { tasks: result } : { profiles: result };
+    }
+    if (method === "DELETE") {
+        if (typeof result !== "boolean")
+            throw new ProviderRequestError(502, "Smooth returned an invalid operation result", undefined, "provider_error");
+        return { success: result };
+    }
+    const object = requiredResponseRecord(result, "Smooth response result");
+    if (!optionalRawString(object.id)?.trim())
+        throw new ProviderRequestError(502, "Smooth response is missing an ID", undefined, "provider_error");
+    if (action.name !== "create_profile" && !optionalRawString(object.status)?.trim())
+        throw new ProviderRequestError(502, "Smooth task is missing status", undefined, "provider_error");
+    return object;
+});
+export const executors = defineApiKeyProviderExecutors("smooth", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input) {
+        requiredInputString(input.apiKey, "API Key");
+        return {
+            profile: { displayName: "Smooth API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationMode: "local_non_empty_key" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "smooth",
+    baseUrl,
+    auth: { type: "api_key_header", name: "apikey" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "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/tapd/actions.d.ts

@@ -0,0 +1,8 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const tapdFamilies: Array<{
+    name: string;
+    path: string;
+    wrapper: string;
+    filters: string;
+}>;
+export declare const tapdActions: ActionDefinition[];

package/src/providers/tapd/actions.js

@@ -0,0 +1,89 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+export const tapdFamilies = [
+    {
+        name: "stories",
+        path: "stories",
+        wrapper: "Story",
+        filters: "id, name, status, owner, iteration_id, priority_label, created, modified, custom_field_* and custom_plan_field_*",
+    },
+    {
+        name: "bugs",
+        path: "bugs",
+        wrapper: "Bug",
+        filters: "id, title, status, severity, current_owner, iteration_id, module, priority_label, created, modified, custom_field_* and custom_plan_field_*",
+    },
+    {
+        name: "tasks",
+        path: "tasks",
+        wrapper: "Task",
+        filters: "id, name, status, owner, story_id, iteration_id, priority_label, created, modified and custom_field_*",
+    },
+    {
+        name: "iterations",
+        path: "iterations",
+        wrapper: "Iteration",
+        filters: "id, name, status, creator, startdate, enddate, workitem_type_id, plan_app_id, created, modified and custom_field_*",
+    },
+    {
+        name: "wikis",
+        path: "tapd_wikis",
+        wrapper: "Wiki",
+        filters: "name, modifier, creator, note, view_count, created and modified; id is supported only by list_wikis",
+    },
+];
+const workspaceId = s.nonEmptyString("TAPD project ID, supplied as a string to preserve precision.");
+const itemsOutput = s.requiredObject("Requested TAPD records.", {
+    items: s.array("Records with the TAPD entity wrapper removed.", s.looseObject("TAPD record, including custom fields and future upstream fields.")),
+});
+export const tapdActions = [
+    defineProviderAction("tapd", {
+        name: "list_projects",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List all projects in a TAPD company. This endpoint does not paginate.",
+        inputSchema: s.requiredObject("Company project query.", {
+            company_id: s.nonEmptyString("TAPD company ID."),
+            category: s.optional(s.string("Project categories, comma-separated: organization, product, project, mini_project or program.")),
+            with_extends: s.optional(s.integer("Set to 1 to include custom project fields.", { minimum: 0, maximum: 1 })),
+        }),
+        outputSchema: itemsOutput,
+    }),
+    defineProviderAction("tapd", {
+        name: "get_project",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve a TAPD project by its workspace ID.",
+        inputSchema: s.requiredObject("Project lookup.", { workspace_id: workspaceId }),
+        outputSchema: s.requiredObject("Project lookup result.", {
+            project: s.looseObject("TAPD project, including its ID, name and provider-defined fields."),
+        }),
+    }),
+];
+for (const family of tapdFamilies) {
+    const filters = s.optional(s.record(`Official TAPD query filters, including ${family.filters}. Values use upstream query syntax, such as comma-separated IDs or >2026-01-01 timestamps. Do not pre-encode values. Pagination, fields, order, workspace_id and format cannot be set here.`, s.string("Upstream filter value; use strings for IDs, numbers and date expressions.")));
+    tapdActions.push(defineProviderAction("tapd", {
+        name: `list_${family.name}`,
+        operationType: "read",
+        requiredScopes: [],
+        description: `Query one page of TAPD ${family.name}. Filter by id to retrieve specific records. Continue with the next page until an empty page is returned.`,
+        inputSchema: s.requiredObject("Paginated project records query.", {
+            workspace_id: workspaceId,
+            filters,
+            page: s.optional(s.integer("Page number, starting at 1. Defaults to 1.", { minimum: 1 })),
+            limit: s.optional(s.integer("Records per page. Defaults to 30; maximum 200.", { minimum: 1, maximum: 200 })),
+            fields: s.optional(s.nonEmptyString("Comma-separated upstream field names to return.")),
+            order: s.optional(s.nonEmptyString("Upstream sort expression, for example created desc. Do not URL-encode.")),
+        }),
+        outputSchema: itemsOutput,
+    }), defineProviderAction("tapd", {
+        name: `count_${family.name}`,
+        operationType: "read",
+        requiredScopes: [],
+        description: `Count TAPD ${family.name} matching the supplied project and filters.`,
+        inputSchema: s.requiredObject("Project records count query.", { workspace_id: workspaceId, filters }),
+        outputSchema: s.requiredObject("Matching record count.", {
+            count: s.integer("Number of matching records.", { minimum: 0 }),
+        }),
+    }));
+}

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

@@ -0,0 +1,137 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, providerUserAgent, ProviderRequestError, runProviderRequest, isAbortLikeError, basicAuthorizationHeader, defineProviderExecutors, requireApiKeyCredential, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { tapdActions, tapdFamilies } from "./actions.js";
+const baseUrl = "https://api.tapd.cn";
+const reservedFilters = new Set(["workspace_id", "page", "limit", "fields", "order", "format"]);
+function authorization(input) {
+    const username = requiredInputString(input.values?.apiUser, "apiUser");
+    if (username.includes(":"))
+        throw new ProviderRequestError(400, "apiUser must not contain a colon", undefined, "invalid_input");
+    return basicAuthorizationHeader(`${username}:${requiredInputString(input.apiKey, "API Key")}`);
+}
+function unwrap(value, wrapper) {
+    const record = requiredResponseRecord(value, "TAPD record wrapper");
+    return requiredResponseRecord(record[wrapper], `TAPD ${wrapper}`);
+}
+async function request({ path, query, auth, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "TAPD" }, async (signal) => {
+        const url = new URL(path, baseUrl);
+        url.search = query.toString();
+        const response = await fetcher(url.toString(), {
+            method: "GET",
+            headers: {
+                authorization: auth,
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+            },
+            signal,
+        });
+        let payload;
+        try {
+            payload = requiredResponseRecord(await response.json(), "TAPD response");
+        }
+        catch (error) {
+            if (isAbortLikeError(error))
+                throw error;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, "TAPD returned an invalid JSON response", undefined, "provider_error");
+        }
+        if (!response.ok || payload.status !== 1) {
+            const detail = path === "/quickstart/testauth" ? undefined : optionalRawString(payload.info);
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `TAPD request failed${detail ? `: ${detail}` : ""}`, undefined, "provider_error");
+        }
+        return payload;
+    });
+}
+const handlers = mapProviderActionHandlers("tapd", tapdActions, (action) => async (dataInput, context) => {
+    const values = dataInput;
+    const query = new URLSearchParams();
+    const filters = optionalRecord(values.filters) ?? {};
+    for (const [key, value] of Object.entries(filters)) {
+        if (reservedFilters.has(key))
+            throw new ProviderRequestError(400, `filters must not contain ${key}`, undefined, "invalid_input");
+        query.set(key, String(value));
+    }
+    for (const [key, value] of Object.entries(values)) {
+        if (key !== "filters" && value != null)
+            query.set(key, String(value));
+    }
+    let path;
+    let wrapper;
+    const count = action.name.startsWith("count_");
+    if (action.name === "list_projects") {
+        path = "/workspaces/projects";
+        wrapper = "Workspace";
+    }
+    else if (action.name === "get_project") {
+        path = "/workspaces/get_workspace_info";
+        wrapper = "Workspace";
+    }
+    else {
+        const family = tapdFamilies.find((item) => action.name === `list_${item.name}` || action.name === `count_${item.name}`);
+        path = `/${family.path}${count ? "/count" : ""}`;
+        wrapper = family.wrapper;
+        if (!count) {
+            query.set("page", String(values.page ?? 1));
+            query.set("limit", String(values.limit ?? 30));
+        }
+    }
+    const payload = await request({
+        path: path,
+        query: query,
+        auth: authorization(context),
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+    if (count) {
+        const result = requiredResponseRecord(payload.data, "TAPD count");
+        const countValue = typeof result.count === "string" && result.count.trim() !== "" ? Number(result.count) : result.count;
+        if (typeof countValue !== "number" || !Number.isInteger(countValue) || countValue < 0)
+            throw new ProviderRequestError(502, "TAPD returned an invalid count", undefined, "provider_error");
+        return { count: countValue };
+    }
+    if (action.name === "get_project")
+        return { project: unwrap(payload.data, wrapper) };
+    if (!Array.isArray(payload.data))
+        throw new ProviderRequestError(502, "TAPD returned an invalid record list", undefined, "provider_error");
+    return { items: payload.data.map((item) => unwrap(item, wrapper)) };
+});
+export const executors = defineProviderExecutors({
+    service: "tapd",
+    handlers,
+    skipDnsValidation: true,
+    async createContext(context, fetcher) {
+        const credential = await requireApiKeyCredential(context, "tapd");
+        return { apiKey: credential.apiKey, values: credential.values, fetcher, signal: context.signal };
+    },
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request({
+            path: "/quickstart/testauth",
+            query: new URLSearchParams(),
+            auth: authorization({ apiKey: input.apiKey, values: input.values }),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        return {
+            profile: { displayName: "TAPD API Account" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationEndpoint: "/quickstart/testauth" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "tapd",
+    baseUrl,
+    auth: { type: "none" },
+    skipDnsValidation: true,
+    async customizeRequest({ context, headers }) {
+        const credential = await requireApiKeyCredential(context, "tapd");
+        headers.set("authorization", authorization(credential));
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "TAPD request failed"), withRetryAfterSeconds(response), "provider_error");
+    },
+});

package/src/providers/teable/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, nullableString, objectArray, optionalBoolean, optionalInteger, optionalRecord, optionalString, } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const teableApiBaseUrl = "https://app.teable.cn/api";
 const teableCurrentUserPath = "/auth/user";
 export const teableActionHandlers = {
@@ -47,9 +47,6 @@ async function executeGetCurrentUser(context) {
     });
     return parseCurrentUser(payload);
 }
-function providerError(_code, message, status) {
-    return new ProviderRequestError(status, message);
-}
 async function executeListSpaces(context) {
     const payload = await teableRequest("/space", {
         ...context,
@@ -160,7 +157,7 @@ async function teableRequest(path, input) {
         if (error instanceof ProviderRequestError) {
             throw error;
         }
-        throw providerError("provider_error", error instanceof Error ? `Teable request failed: ${error.message}` : "Teable request failed", 502);
+        throw providerResponseError(error instanceof Error ? `Teable request failed: ${error.message}` : "Teable request failed");
     }
     if (!response.ok) {
         throw createTeableError(response, payload, input.phase);
@@ -188,7 +185,7 @@ async function readTeablePayload(response) {
     }
     catch (error) {
         if (response.ok) {
-            throw providerError("provider_error", error instanceof Error ? `Teable returned malformed JSON: ${error.message}` : "Teable returned malformed JSON", 502);
+            throw providerResponseError(error instanceof Error ? `Teable returned malformed JSON: ${error.message}` : "Teable returned malformed JSON");
         }
         return text;
     }
@@ -196,21 +193,21 @@ async function readTeablePayload(response) {
 function createTeableError(response, payload, phase) {
     const message = extractTeableErrorMessage(payload) || response.statusText || "Teable request failed";
     if (response.status === 429) {
-        return providerError("rate_limited", message, 429);
+        return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && (response.status === 401 || response.status === 403)) {
-        return providerError("invalid_input", message, 400);
+        return providerInputError(message);
     }
     if (phase === "execute" && response.status === 401) {
-        return providerError("credential_expired", message, 401);
+        return new ProviderRequestError(401, message);
     }
     if (phase === "execute" && response.status === 403) {
-        return providerError("scope_missing", message, 403);
+        return new ProviderRequestError(403, message);
     }
     if (phase === "execute" && [400, 404, 422].includes(response.status)) {
-        return providerError("invalid_input", message, 400);
+        return providerInputError(message);
     }
-    return providerError("provider_error", message, response.status || 500);
+    return new ProviderRequestError(response.status || 500, message);
 }
 function extractTeableErrorMessage(payload) {
     const root = optionalRecord(payload);
@@ -224,7 +221,7 @@ function parseCurrentUser(payload) {
     const id = optionalString(user.id);
     const name = optionalString(user.name);
     if (!id || !name) {
-        throw providerError("provider_error", "Teable current user response did not include id and name", 502);
+        throw providerResponseError("Teable current user response did not include id and name");
     }
     return compactObject({
         id,
@@ -236,7 +233,7 @@ function parseCurrentUser(payload) {
 function requireObject(payload, label) {
     const value = optionalRecord(payload);
     if (!value) {
-        throw providerError("provider_error", `Teable returned an invalid ${label} response`, 502);
+        throw providerResponseError(`Teable returned an invalid ${label} response`);
     }
     return value;
 }
@@ -245,7 +242,7 @@ function requireObjectArray(payload, label) {
         return objectArray(payload, label);
     }
     catch {
-        throw providerError("provider_error", `Teable returned an invalid ${label} response`, 502);
+        throw providerResponseError(`Teable returned an invalid ${label} response`);
     }
 }
 function recordReadSearchParams(input) {

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

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