@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/youzan/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, ProviderRequestError, providerUserAgent, toProviderExecutionError, } from "../provider-runtime.js";
+import { createProviderTimeout, ProviderRequestError, providerUserAgent, toProviderExecutionError, providerInputError, } from "../provider-runtime.js";
 export const youzanApiBaseUrl = "https://open.youzanyun.com";
 const youzanTokenUrl = `${youzanApiBaseUrl}/auth/token`;
 export async function validateYouzanCredential(values, fetcher, signal) {
@@ -22,10 +22,10 @@ export function resolveYouzanCredential(input) {
     const clientSecret = optionalString(input.clientSecret);
     const grantId = optionalString(input.grantId);
     if (!clientId || !clientSecret || !grantId) {
-        throw new ProviderRequestError(400, "youzan clientId, clientSecret, and grantId are required");
+        throw providerInputError("youzan clientId, clientSecret, and grantId are required");
     }
     if ([...grantId].some((character) => character < "0" || character > "9")) {
-        throw new ProviderRequestError(400, "youzan grantId must contain only digits");
+        throw providerInputError("youzan grantId must contain only digits");
     }
     return { clientId, clientSecret, grantId };
 }
@@ -202,7 +202,7 @@ export const youzanActionHandlers = {
 function validatePageWindow(input, defaultPageSize, maximum) {
     const page = optionalInteger(input.page) ?? 1;
     if (page * (optionalInteger(input.pageSize) ?? defaultPageSize) > maximum) {
-        throw new ProviderRequestError(400, `page multiplied by pageSize cannot exceed ${maximum}`);
+        throw providerInputError(`page multiplied by pageSize cannot exceed ${maximum}`);
     }
 }
 function validateOrderTimePairs(input) {
@@ -212,7 +212,7 @@ function validateOrderTimePairs(input) {
         ["completedAfter", "completedBefore"],
     ]) {
         if ((input[after] !== undefined) !== (input[before] !== undefined)) {
-            throw new ProviderRequestError(400, `${after} and ${before} must be provided together`);
+            throw providerInputError(`${after} and ${before} must be provided together`);
         }
     }
 }
@@ -233,7 +233,7 @@ async function requestYouzanApi(api, version, body, context) {
         throw createYouzanApiError(response.status, payload);
     }
     if (payload.data === undefined || payload.data === null) {
-        throw youzanError("provider_error", "Youzan returned an invalid data payload", 502);
+        throw new ProviderRequestError(502, "Youzan returned an invalid data payload", undefined, "provider_error");
     }
     return payload.data;
 }
@@ -249,19 +249,19 @@ async function fetchYouzanJson(url, init, fetcher, parentSignal) {
             parsed = JSON.parse(text);
         }
         catch {
-            throw youzanError("provider_error", "Youzan returned invalid JSON", 502);
+            throw new ProviderRequestError(502, "Youzan returned invalid JSON", undefined, "provider_error");
         }
         const payload = optionalRecord(parsed);
         if (!payload)
-            throw youzanError("provider_error", "Youzan returned invalid JSON", 502);
+            throw new ProviderRequestError(502, "Youzan returned invalid JSON", undefined, "provider_error");
         return { response, payload };
     }
     catch (error) {
         if (error instanceof ProviderRequestError)
             throw error;
         if (timeout.didTimeout())
-            throw youzanError("provider_error", "Youzan request timed out", 504);
-        throw youzanError("provider_error", error instanceof Error ? `Youzan request failed: ${error.message}` : "Youzan request failed", 502);
+            throw new ProviderRequestError(504, "Youzan request timed out", undefined, "provider_error");
+        throw new ProviderRequestError(502, error instanceof Error ? `Youzan request failed: ${error.message}` : "Youzan request failed", undefined, "provider_error");
     }
     finally {
         timeout.cleanup();
@@ -270,21 +270,21 @@ async function fetchYouzanJson(url, init, fetcher, parentSignal) {
 function createYouzanTokenError(status, payload, phase) {
     const message = readYouzanMessage(payload, "Youzan rejected the application credentials");
     if (status === 429)
-        return youzanError("rate_limited", message, 429, payload);
+        return new ProviderRequestError(429, message, payload, "rate_limited");
     if (status >= 500)
-        return youzanError("provider_error", message, 502, payload);
+        return new ProviderRequestError(502, message, payload, "provider_error");
     return phase === "validate"
-        ? youzanError("invalid_input", message, 400, payload)
-        : youzanError("authorization_failed", message, 401, payload);
+        ? new ProviderRequestError(400, message, payload, "invalid_input")
+        : new ProviderRequestError(401, message, payload, "authorization_failed");
 }
 function createYouzanApiError(status, payload) {
     const message = readYouzanMessage(payload, "Youzan API request failed");
     if (status === 429)
-        return youzanError("rate_limited", message, 429, payload);
+        return new ProviderRequestError(429, message, payload, "rate_limited");
     if (status === 401 || status === 403 || payload.code === 40010) {
-        return youzanError("authorization_failed", message, 401, payload);
+        return new ProviderRequestError(401, message, payload, "authorization_failed");
     }
-    return youzanError("provider_error", message, 502, payload);
+    return new ProviderRequestError(502, message, payload, "provider_error");
 }
 function readYouzanMessage(payload, fallback) {
     return optionalString(payload.message) ?? optionalString(payload.msg) ?? fallback;
@@ -292,24 +292,21 @@ function readYouzanMessage(payload, fallback) {
 function requireObject(value, label) {
     const object = optionalRecord(value);
     if (!object)
-        throw youzanError("provider_error", `${label} payload is invalid`, 502);
+        throw new ProviderRequestError(502, `${label} payload is invalid`, undefined, "provider_error");
     return object;
 }
 function requireObjectArray(value, label) {
     if (!Array.isArray(value))
-        throw youzanError("provider_error", `${label} payload is invalid`, 502);
+        throw new ProviderRequestError(502, `${label} payload is invalid`, undefined, "provider_error");
     const objects = value.map(optionalRecord);
     if (objects.some((item) => item === undefined)) {
-        throw youzanError("provider_error", `${label} payload is invalid`, 502);
+        throw new ProviderRequestError(502, `${label} payload is invalid`, undefined, "provider_error");
     }
     return objects;
 }
 function requireNonNegativeInteger(value, label) {
     if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
-        throw youzanError("provider_error", `${label} payload is invalid`, 502);
+        throw new ProviderRequestError(502, `${label} payload is invalid`, undefined, "provider_error");
     }
     return value;
 }
-function youzanError(code, message, status, details) {
-    return new ProviderRequestError(status, message, details, code);
-}

package/src/providers/zenkit/runtime.js

@@ -1,4 +1,4 @@
-import { optionalRecord, optionalString } from "../../core/cast.js";
+import { booleanString, optionalRecord, optionalString } from "../../core/cast.js";
 import { ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
 export const zenkitApiBaseUrl = "https://base.zenkit.com/api/v1";
 const zenkitValidationPath = "/auth/currentuser";
@@ -57,7 +57,7 @@ async function listWorkspacesAndLists(context) {
         phase: "execute",
     });
     if (!Array.isArray(payload)) {
-        throw providerError("provider_error", "Zenkit workspaces response must be an array", 502);
+        throw new ProviderRequestError(502, "Zenkit workspaces response must be an array", undefined, "provider_error");
     }
     return { workspaces: payload };
 }
@@ -90,10 +90,10 @@ async function searchEntries(input, context) {
             limit: stringifyOptionalNumber(input.limit),
             preferredListIds: stringifyOptionalArray(input.preferredListIds),
             excludeListEntryUUIDs: stringifyOptionalArray(input.excludeEntryUuids),
-            searchInArchive: stringifyOptionalBoolean(input.searchInArchive),
-            includeRelatedLists: stringifyOptionalBoolean(input.includeRelatedLists),
-            includeRelatedWorkspaces: stringifyOptionalBoolean(input.includeRelatedWorkspaces),
-            includeRelatedListElements: stringifyOptionalBoolean(input.includeRelatedListElements),
+            searchInArchive: booleanString(input.searchInArchive),
+            includeRelatedLists: booleanString(input.includeRelatedLists),
+            includeRelatedWorkspaces: booleanString(input.includeRelatedWorkspaces),
+            includeRelatedListElements: booleanString(input.includeRelatedListElements),
         },
     });
     return { results: requiredResponseRecord(payload, "Zenkit entry search response") };
@@ -181,21 +181,21 @@ async function readZenkitPayload(response) {
         if (!response.ok) {
             return { message: text.trim().slice(0, 500) };
         }
-        throw providerError("provider_error", "Zenkit returned invalid JSON", 502);
+        throw new ProviderRequestError(502, "Zenkit returned invalid JSON", undefined, "provider_error");
     }
 }
 function mapZenkitError(status, payload, phase) {
     const message = readZenkitErrorMessage(payload) ?? `Zenkit request failed with status ${status}`;
     if (status === 429) {
-        return providerError("rate_limited", message, 429);
+        return new ProviderRequestError(429, message, undefined, "rate_limited");
     }
     if (phase === "validate" && status >= 400 && status < 500) {
-        return providerError("invalid_input", message, 400);
+        return new ProviderRequestError(400, message, undefined, "invalid_input");
     }
     if (status === 400 || status === 404 || status === 409 || status === 422) {
-        return providerError("invalid_input", message, status === 404 ? 404 : 400);
+        return new ProviderRequestError(status === 404 ? 404 : 400, message, undefined, "invalid_input");
     }
-    return providerError("provider_error", message, status || 502);
+    return new ProviderRequestError(status || 502, message, undefined, "provider_error");
 }
 function readZenkitErrorMessage(payload) {
     const body = optionalRecord(payload);
@@ -213,26 +213,20 @@ function requireAllId(value, fieldName) {
 }
 function requirePositiveInteger(value, fieldName) {
     if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-        throw providerError("invalid_input", `${fieldName} must be a positive integer`, 400);
+        throw new ProviderRequestError(400, `${fieldName} must be a positive integer`, undefined, "invalid_input");
     }
     return value;
 }
 function requireInputObject(value, fieldName) {
     const object = optionalRecord(value);
     if (!object) {
-        throw providerError("invalid_input", `${fieldName} must be an object`, 400);
+        throw new ProviderRequestError(400, `${fieldName} must be an object`, undefined, "invalid_input");
     }
     return object;
 }
 function stringifyOptionalNumber(value) {
     return typeof value === "number" ? String(value) : undefined;
 }
-function stringifyOptionalBoolean(value) {
-    return typeof value === "boolean" ? String(value) : undefined;
-}
 function stringifyOptionalArray(value) {
     return Array.isArray(value) ? value.join(",") : undefined;
 }
-function providerError(code, message, status) {
-    return new ProviderRequestError(status, message, undefined, code);
-}

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

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

package/src/providers/zhiliaobiaoxun/actions.js

@@ -0,0 +1,138 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const bidFields = {
+    bid_id: s.integer("The notice ID."),
+    title: s.string("The notice title."),
+    bid_type: s.string("The notice type returned by the provider, such as 招标 or 中标."),
+    bid_process: s.string("The procurement stage name."),
+    pub_time: s.string("The publication time as returned by the provider."),
+    money: s.nullable(s.number("The amount in CNY.")),
+    money_wan: s.nullable(s.number("The amount in ten thousand CNY.")),
+    province: s.string("The province name."),
+    city: s.string("The city name."),
+    county: s.string("The county or district name."),
+    caller_name: s.string("The purchaser name."),
+    winner_names: s.array("Winning suppliers.", s.string("A supplier name.")),
+    url: s.string("The notice URL on Zhiliao Biaoxun."),
+};
+const meta = s.looseObject("Request and billing metadata.", {
+    request_id: s.string("The upstream request ID."),
+    tool_name: s.string("The upstream tool name."),
+    cost_units: s.number("Credits charged for this request."),
+    execution_time_ms: s.number("Upstream execution time in milliseconds."),
+});
+function output(data) {
+    return s.looseRequiredObject("The successful upstream response, including billing metadata.", {
+        success: s.literal(true, { description: "Whether the request succeeded." }),
+        data,
+        error: s.nullable(s.looseObject("Upstream error information; null on success.", {})),
+        meta,
+    });
+}
+const bidList = s.looseObject("Matching procurement notices.", {
+    total: s.integer("The total number of matching notices."),
+    returned: s.integer("The number of notices returned on this page."),
+    items: s.array("Notices on this page.", s.looseObject("A procurement notice.", bidFields)),
+});
+const identity = {
+    bid_id: s.integer("The notice ID; pair it with bid_type."),
+    bid_type: s.integer("The notice type: 1 for tenders, 2 for awards.", { minimum: 1, maximum: 2 }),
+    bid_url: s.nonWhitespaceString("The notice URL; forwarded to the provider without downloading it."),
+};
+export const zhiliaobiaoxunActions = [
+    defineProviderAction("zhiliaobiaoxun", {
+        name: "search_bids",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search Chinese tender and award notices by keywords, region, publication date, or amount. Returns one page per call and charges provider credits. Increase page to continue.",
+        inputSchema: s.object("Notice search filters.", {
+            keywords: s.array("Search keywords.", s.nonWhitespaceString("A search keyword."), {
+                minItems: 1,
+            }),
+            match_modes: s.array("Fields in which to match keywords; omit for provider defaults.", s.stringEnum("A keyword matching mode.", [
+                "all",
+                "sm",
+                "title",
+                "brand",
+                "fulltext",
+                "caller",
+                "winner",
+                "winner_tender",
+                "tender",
+                "agency",
+            ])),
+            bid_type: s.stringEnum("Notice category: 招标 for tenders, 中标 for awards, 全部 for both.", [
+                "招标",
+                "中标",
+                "全部",
+            ]),
+            bid_process: s.array("Procurement stages: 1 intent, 2 pre-tender, 4 tender, 5 amendment, 6 award candidates, 7 award, 8 contract, 9 acceptance, 10 cancellation. Default: [1,2,4,7,8].", s.integer("A procurement stage ID.")),
+            begin_date: s.string("Inclusive publication start date, YYYY-MM-DD.", { format: "date" }),
+            end_date: s.string("Inclusive publication end date, YYYY-MM-DD.", { format: "date" }),
+            provinces: s.array("Province names, such as 北京 or 内蒙古.", s.nonWhitespaceString("A province name.")),
+            cities: s.array("City names, such as 石家庄 or 合肥.", s.nonWhitespaceString("A city name.")),
+            counties: s.array("County or district names, such as 长安区.", s.nonWhitespaceString("A county or district name.")),
+            min_amount: s.number("Minimum amount in ten thousand CNY."),
+            max_amount: s.number("Maximum amount in ten thousand CNY."),
+            page: s.integer("Page number, starting at 1; defaults to 1.", { minimum: 1, default: 1 }),
+            page_size: s.integer("Notices per page; defaults to 20.", { minimum: 1, default: 20 }),
+        }, { required: ["keywords"] }),
+        outputSchema: output(bidList),
+    }),
+    defineProviderAction("zhiliaobiaoxun", {
+        name: "get_bid_detail",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a procurement notice with its full text and attachment links. Supply a notice URL, unique key, or notice ID. Charges provider credits; attachments are returned as URLs.",
+        inputSchema: {
+            ...s.object("Notice identifiers; supply at least one locator.", {
+                ...identity,
+                uniq_key: s.nonWhitespaceString("The provider's unique notice key."),
+            }, { required: [] }),
+            anyOf: [{ required: ["bid_id"] }, { required: ["bid_url"] }, { required: ["uniq_key"] }],
+        },
+        outputSchema: output(s.looseObject("Notice details, preserving additional provider fields.", {
+            ...bidFields,
+            uniq_key: s.string("The provider's unique notice key."),
+            source: s.string("The notice body."),
+            source_ext: s.string("Extracted attachment content."),
+            source_url: s.string("The original publication URL."),
+            attachment_urls: s.array("Attachment URLs; no files are downloaded by this action.", s.string("An attachment URL.")),
+            contact_privacy: s.string("Provider contact visibility: full or masked, depending on the account."),
+        })),
+    }),
+    defineProviderAction("zhiliaobiaoxun", {
+        name: "get_bid_timeline",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve notices for every stage of the same procurement project, ordered by publication time ascending. Supply a notice URL or a notice ID with its type. Charges provider credits.",
+        inputSchema: {
+            ...s.object("A notice identifying the procurement project.", {
+                ...identity,
+                bid_type: {
+                    type: ["integer", "string"],
+                    enum: [1, 2, "1", "2"],
+                    description: "The notice type: 1 for tenders, 2 for awards; numeric strings are accepted.",
+                },
+            }, { required: [] }),
+            anyOf: [{ required: ["bid_url"] }, { required: ["bid_id", "bid_type"] }],
+        },
+        outputSchema: output(s.looseObject("The project timeline.", {
+            total: s.integer("The number of notices across project stages."),
+            items: s.array("Project notices ordered by publication time ascending.", s.looseObject("A procurement notice.", bidFields)),
+        })),
+    }),
+    defineProviderAction("zhiliaobiaoxun", {
+        name: "get_account_balance",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read available credits and cumulative charged and consumed credits for the connected account. This endpoint does not consume credits.",
+        inputSchema: s.requiredObject("No input parameters are required.", {}),
+        outputSchema: output(s.looseObject("Account credit balance.", {
+            user_id: s.integer("The account ID associated with the API key."),
+            balance: s.number("Available credits."),
+            total_charged: s.number("Cumulative credits added to the account."),
+            total_consumed: s.number("Cumulative credits consumed."),
+        })),
+    }),
+];

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

@@ -0,0 +1,78 @@
+import { optionalRecord, optionalRawString, optionalNumber } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { zhiliaobiaoxunActions } from "./actions.js";
+const baseUrl = "https://mcp-server.zhiliaobiaoxun.com/api_v2";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+async function request({ actionName, body, apiKey, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "Zhiliao Biaoxun" }, async (signal) => {
+        const isBalance = actionName === "get_account_balance";
+        const response = await fetcher(`${baseUrl}/${isBalance ? "account/balance" : actionName}`, {
+            method: isBalance ? "GET" : "POST",
+            headers: { ...defaultHeaders, "X-API-Key": apiKey },
+            signal,
+            body: isBalance ? undefined : 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?.success !== true) {
+            const error = optionalRecord(envelope?.error);
+            const code = optionalRawString(error?.code);
+            const message = optionalRawString(error?.message) || `HTTP ${response.status}; invalid or unsuccessful response`;
+            const detail = [code, message].filter(Boolean).join(": ").split(apiKey).join("[REDACTED]");
+            const limited = response.status === 429 || code === "RATE_LIMITED";
+            throw new ProviderRequestError(response.ok ? (limited ? 429 : 502) : response.status, `Zhiliao Biaoxun request failed: ${detail}`, undefined, limited ? "rate_limited" : "provider_error");
+        }
+        return envelope;
+    });
+}
+const handlers = mapProviderActionHandlers("zhiliaobiaoxun", zhiliaobiaoxunActions, (action) => async (dataInput, context) => {
+    return request({
+        actionName: action.name,
+        body: dataInput,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("zhiliaobiaoxun", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const response = await request({
+            actionName: "get_account_balance",
+            body: {},
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        const data = requiredResponseRecord(response.data, "Zhiliao Biaoxun account data");
+        const userId = optionalNumber(data.user_id);
+        return {
+            profile: { displayName: userId == null ? "Zhiliao Biaoxun API Key" : `Zhiliao Biaoxun ${userId}` },
+            grantedScopes: [],
+            metadata: {},
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "zhiliaobiaoxun",
+    baseUrl,
+    auth: { type: "api_key_header", name: "X-API-Key" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/json", "content-type": "application/json" }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

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

@@ -1,5 +1,6 @@
 import { defineOAuthProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { fetchZoomCurrentAccount, zoomActionHandlers, zoomApiBaseUrl } from "./runtime.js";
+import { zoomRecordingReady } from "./trigger-on-recording-ready.js";
 const service = "zoom";
 export const executors = defineOAuthProviderExecutors(service, zoomActionHandlers);
 export const proxy = defineProviderProxy({
@@ -13,3 +14,4 @@ export const credentialValidators = {
         return fetchZoomCurrentAccount(input.accessToken, input.metadata, fetcher, signal);
     },
 };
+export const triggers = [zoomRecordingReady];

package/src/providers/zoom/trigger-on-recording-ready.d.ts

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

package/src/providers/zoom/trigger-on-recording-ready.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/zoom/trigger-on-recording-ready.definition.js

@@ -0,0 +1,44 @@
+export const snapshot = {
+    key: "zoom.on_recording_ready",
+    provider: "zoom",
+    name: "on_recording_ready",
+    displayName: "Cloud Recording Ready",
+    description: "Receives completed cloud recordings hosted by the connected Zoom user through a verified application event source.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "sourceId",
+            jsonSchema: { type: "string", pattern: "^source_[0-9a-f]{32}$", title: "Event source" },
+            nullable: false,
+        },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: ["recording.completed"],
+                },
+                minItems: 1,
+                maxItems: 1,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["recording.completed"],
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "accountId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "meetingUuid", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/zoom/trigger-on-recording-ready.js

@@ -0,0 +1,39 @@
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { webhookRequest } from "../../triggers/managed-webhook.js";
+import { zoomApplication } from "../../triggers/sources/zoom.js";
+import { snapshot } from "./trigger-on-recording-ready.definition.js";
+export const zoomRecordingReady = {
+    snapshot,
+    eventSource: "zoom",
+    source: zoomApplication,
+    async sourceIdentity(context) {
+        const result = await webhookRequest(context, { method: "GET", endpoint: "/users/me" });
+        if (!context.connector.providerAccountId ||
+            !isJsonObject(result.data) ||
+            typeof result.data.id !== "string" ||
+            !result.data.id ||
+            typeof result.data.account_id !== "string" ||
+            !result.data.account_id)
+            throw new PermanentIntegrationError("Zoom did not return a verified user and account identity.");
+        return {
+            accountId: context.connector.providerAccountId,
+            userId: result.data.id,
+            zoomAccountId: result.data.account_id,
+        };
+    },
+    receive(context) {
+        if (context.eventSourceId !== context.config.sourceId)
+            return { outcome: "respond", status: 404, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) ||
+            typeof payload.deliveryId !== "string" ||
+            !payload.deliveryId ||
+            !isJsonObject(payload.body))
+            throw new PermanentIntegrationError("Invalid shared Zoom event.");
+        return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+    },
+    async reconcile() {
+        throw new PermanentIntegrationError("This deployment does not support shared Zoom event sources.");
+    },
+};

package/src/server/api/action-example.js

@@ -33,6 +33,14 @@ export function buildExampleInput(schema) {
             }
         }
     }
+    // De Morgan's law exposes positive choices encoded as not(allOf(not(...))).
+    if (isSchemaObject(seedSchema.not) && Array.isArray(seedSchema.not.allOf)) {
+        const members = seedSchema.not.allOf;
+        if (members.length > 0 && members.every((member) => isSchemaObject(member) && isSchemaObject(member.not))) {
+            const choices = members.map((member) => member.not);
+            seedRequirementBranches({ ...seedSchema, not: undefined, anyOf: choices }, properties, input);
+        }
+    }
     applyConditionalRequirements(seedSchema, seedSchema, input);
     return input;
 }
@@ -293,7 +301,10 @@ function stringExample(schema) {
     const minLength = typeof schema.minLength === "number" && schema.minLength > 0 ? schema.minLength : 0;
     const maxLength = typeof schema.maxLength === "number" ? schema.maxLength : undefined;
     if (typeof schema.format === "string") {
-        return formatStringExample(schema.format, minLength, maxLength);
+        const formatted = formatStringExample(schema.format, minLength, maxLength);
+        if (new Validator(schema, "2020-12").validate(formatted).valid) {
+            return formatted;
+        }
     }
     if (typeof schema.pattern === "string") {
         const sample = samplePattern(schema.pattern, { minLength });

package/src/server/api/auth.d.ts

@@ -7,6 +7,8 @@ import type { Context, MiddlewareHandler } from "hono";
 export interface LocalAuthOptions {
     adminToken?: string;
     runtimeToken?: string;
+    /** Keep runtime endpoints protected even when the last stored token is revoked. */
+    requireRuntimeAuth?: boolean;
     hasRuntimeTokens?(): Promise<boolean>;
     resolveRuntimeToken?(token: string): Promise<RuntimeGrant | undefined>;
     verifyRuntimeJwt?: RuntimeJwtVerifier;

package/src/server/api/auth.js

@@ -20,6 +20,7 @@ export function createLocalAuthMiddleware(options) {
     const runtimeToken = normalizeToken(options.runtimeToken);
     if (!adminToken &&
         !runtimeToken &&
+        !options.requireRuntimeAuth &&
         !options.hasRuntimeTokens &&
         !options.resolveRuntimeToken &&
         !options.verifyRuntimeJwt) {
@@ -140,7 +141,7 @@ async function hasValidToken(context, options, scope) {
         const hasRuntimeTokens = options.hasRuntimeTokens
             ? await options.hasRuntimeTokens()
             : options.resolveRuntimeToken !== undefined;
-        if (!hasRuntimeTokens && !options.verifyRuntimeJwt) {
+        if (!options.requireRuntimeAuth && !hasRuntimeTokens && !options.verifyRuntimeJwt) {
             return true;
         }
         return hasValidRuntimeToken(context, options);

package/src/server/api/console-catalog-routes.d.ts

@@ -0,0 +1,17 @@
+import type { CatalogStore } from "../../catalog-store.ts";
+import type { ConnectionService } from "../../connection-service.ts";
+import type { ActionPolicySnapshot } from "../../core/action-policy.ts";
+import type { ActionSearchDocument, ActionSearchIndexProvider } from "../../core/action-search.ts";
+import type { Context } from "hono";
+import { Hono } from "hono";
+export interface ConsoleCatalogRoutesOptions {
+    catalog: CatalogStore;
+    connections: ConnectionService;
+    actionSearch: ActionSearchIndexProvider;
+    publicOrigin: string;
+    getPolicySnapshot: (context: Context) => Promise<ActionPolicySnapshot>;
+    readConnectionName?: (context: Context, body?: Record<string, unknown>) => string | undefined;
+    serializeSearchResults?: (results: ActionSearchDocument[]) => Promise<unknown[]>;
+}
+/** Console catalog, providers, actions and documentation routes. */
+export declare function createConsoleCatalogRoutes({ catalog, connections, actionSearch, publicOrigin, getPolicySnapshot, readConnectionName, serializeSearchResults: injectedSerializeSearchResults, }: ConsoleCatalogRoutesOptions): Hono;