@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/explorium/actions.js

@@ -0,0 +1,124 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const businessId = s.string("The business ID returned by matching.", { pattern: "^[a-f0-9]{32}$" });
+const requestContext = s.looseObject("Optional request context forwarded to Explorium.", {});
+const responseContext = s.looseObject("Request status and diagnostic context.", {
+    correlation_id: s.string("The upstream correlation ID."),
+    request_status: s.string("The upstream status: success, miss, or failure."),
+    time_took_in_seconds: s.number("Upstream processing time in seconds."),
+});
+const businessAttributes = {
+    ...s.object("Business identifiers; provide at least one.", {
+        name: s.nonWhitespaceString("The business name.", { maxLength: 256 }),
+        domain: s.nonWhitespaceString("The business website domain."),
+        url: s.nonWhitespaceString("The business URL, such as its LinkedIn company URL."),
+    }, { optional: ["name", "domain", "url"] }),
+    minProperties: 1,
+};
+const enrichmentInput = s.object("Enrich one to fifty matched businesses.", {
+    business_ids: s.array("Business IDs to enrich.", businessId, { minItems: 1, maxItems: 50 }),
+    request_context: requestContext,
+    parameters: s.looseObject("Optional enrichment parameters forwarded to Explorium.", {}),
+}, { optional: ["request_context", "parameters"] });
+const firmographics = s.looseObject("Company attributes; additional upstream fields are preserved.", {
+    business_id: s.string("The matched business ID."),
+    name: s.string("The business name."),
+    website: s.string("The business website URL."),
+    country_name: s.string("The business country name."),
+    number_of_employees_range: s.string("The employee count range."),
+    yearly_revenue_range: s.string("The yearly revenue range."),
+    linkedin_profile: s.string("The LinkedIn company profile URL."),
+});
+const technographics = s.looseObject("Technology attributes; additional upstream fields are preserved.", {
+    full_tech_stack: s.array("All detected technologies.", s.string("A technology name.")),
+    full_nested_tech_stack: s.array("Technology details grouped by category.", s.looseObject("An upstream technology record.", {})),
+});
+function enrichmentOutput(dataSchema) {
+    return s.object("Batch enrichment results, including unmatched rows without data.", {
+        response_context: responseContext,
+        total_results: s.integer("The total number of results."),
+        data: s.array("Enrichment results for the supplied business IDs.", s.looseObject("One business enrichment result.", {
+            business_id: s.string("The requested business ID."),
+            data: s.nullable(dataSchema),
+        })),
+    }, { required: ["response_context", "total_results"], additionalProperties: true });
+}
+export const exploriumActions = [
+    defineProviderAction("explorium", {
+        name: "match_businesses",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Match one to fifty businesses by name, domain, or URL to Explorium business IDs. Results preserve input order; unmatched rows have no business ID. Requests may consume credits.",
+        inputSchema: s.object("Business matching input.", {
+            businesses_to_match: s.array("Businesses to match in input order.", businessAttributes, {
+                minItems: 1,
+                maxItems: 50,
+            }),
+            request_context: requestContext,
+        }, { optional: ["request_context"] }),
+        outputSchema: s.object("Business matches in input order.", {
+            response_context: responseContext,
+            total_results: s.integer("The number of submitted business results."),
+            total_matches: s.integer("The number of matched businesses."),
+            matched_businesses: s.array("Matched and unmatched business results.", s.looseObject("One business match.", {
+                input: s.looseObject("The original business identifiers.", {
+                    name: s.string("The submitted business name."),
+                    domain: s.string("The submitted business domain."),
+                    url: s.string("The submitted business URL."),
+                }),
+                business_id: s.nullable(s.string("The matched ID; null or absent when unmatched.")),
+            })),
+        }, { required: ["response_context", "total_results", "total_matches"], additionalProperties: true }),
+    }),
+    defineProviderAction("explorium", {
+        name: "enrich_firmographics",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve company profiles for one to fifty Explorium business IDs, including industry, location, employee count, and revenue. Obtain IDs with match_businesses first. Requests may consume credits.",
+        inputSchema: enrichmentInput,
+        outputSchema: enrichmentOutput(firmographics),
+    }),
+    defineProviderAction("explorium", {
+        name: "enrich_technographics",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve technology stacks for one to fifty Explorium business IDs. Obtain IDs with match_businesses first. Requests may consume credits.",
+        inputSchema: enrichmentInput,
+        outputSchema: enrichmentOutput(technographics),
+    }),
+    defineProviderAction("explorium", {
+        name: "autocomplete_businesses",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Find Explorium business filter values by field and optional partial query, including countries, industries, company names, and technologies.",
+        inputSchema: s.object("Business filter autocomplete input.", {
+            field: s.stringEnum("The field to autocomplete.", [
+                "country",
+                "country_code",
+                "region_country_code",
+                "google_category",
+                "naics_category",
+                "linkedin_category",
+                "company_tech_stack_tech",
+                "company_tech_stack_categories",
+                "job_title",
+                "company_size",
+                "company_revenue",
+                "number_of_locations",
+                "company_age",
+                "job_department",
+                "job_level",
+                "city_region_country",
+                "company_name",
+            ]),
+            query: s.string("Partial search text; omitted means an empty query."),
+        }, { optional: ["query"] }),
+        outputSchema: s.requiredObject("Autocomplete suggestions.", {
+            items: s.array("Suggested filter values.", s.looseObject("One autocomplete suggestion.", {
+                query: s.string("The original search query."),
+                label: s.string("The suggestion display label."),
+                value: s.string("The filter value to use in API requests."),
+            })),
+        }),
+    }),
+];

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

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const credentialValidators: CredentialValidators;
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/explorium/executors.js

@@ -0,0 +1,100 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { providerResponseError, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, requiredInputString, requiredResponseRecord, runProviderRequest, ProviderRequestError, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { exploriumActions } from "./actions.js";
+const baseUrl = "https://api.explorium.ai/v1";
+const endpoints = {
+    match_businesses: "/businesses/match",
+    enrich_firmographics: "/businesses/firmographics/bulk_enrich",
+    enrich_technographics: "/businesses/technographics/bulk_enrich",
+    autocomplete_businesses: "/businesses/autocomplete",
+};
+function requireAutocompleteItems(payload) {
+    if (!Array.isArray(payload)) {
+        throw providerResponseError("Explorium autocomplete response is not an array");
+    }
+    return payload;
+}
+async function request({ endpoint, values, apiKey, fetcher, autocomplete, signal: parentSignal }) {
+    return runProviderRequest({ label: "Explorium", signal: parentSignal }, async (signal) => {
+        const url = new URL(`${baseUrl}${endpoint}`);
+        if (autocomplete) {
+            url.searchParams.set("field", optionalRawString(values.field));
+            if (values.query !== undefined)
+                url.searchParams.set("query", optionalRawString(values.query));
+        }
+        const response = await fetcher(url, {
+            method: autocomplete ? "GET" : "POST",
+            headers: { accept: "application/json", "content-type": "application/json", api_key: apiKey },
+            body: autocomplete ? undefined : JSON.stringify(values),
+            signal,
+        });
+        const text = await response.text();
+        let payload = undefined;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        if (!response.ok) {
+            const record = optionalRecord(payload);
+            const detail = Array.isArray(record?.detail)
+                ? record.detail
+                    .map((item) => optionalRawString(optionalRecord(item)?.msg))
+                    .filter(Boolean)
+                    .join("; ")
+                : optionalRawString(record?.detail);
+            const message = detail ||
+                optionalRawString(record?.message) ||
+                optionalRawString(record?.error) ||
+                optionalRawString(payload) ||
+                (payload === undefined ? text : "");
+            const code = optionalRawString(record?.code);
+            throw new ProviderRequestError(response.status, `${code ? `${code}: ` : ""}${message.trim() || `Explorium request failed with status ${response.status}`}`.replaceAll(apiKey, "[REDACTED]"), undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        if (payload === undefined)
+            throw providerResponseError("Explorium response is not valid JSON");
+        return payload;
+    });
+}
+const handlers = mapProviderActionHandlers("explorium", exploriumActions, (action) => async (values, context) => {
+    const autocomplete = action.name === "autocomplete_businesses";
+    const payload = await request({ ...context, endpoint: endpoints[action.name], values, autocomplete });
+    return autocomplete
+        ? { items: requireAutocompleteItems(payload) }
+        : requiredResponseRecord(payload, "Explorium response");
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = await request({
+            endpoint: "/businesses/autocomplete",
+            values: { field: "country", query: "unit" },
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher,
+            autocomplete: true,
+            signal,
+        });
+        requireAutocompleteItems(payload);
+        return {
+            profile: { displayName: "Explorium API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationEndpoint: "/businesses/autocomplete" },
+        };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("explorium", handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service: "explorium",
+    baseUrl,
+    auth: { type: "api_key_header", name: "api_key" },
+    skipDnsValidation: true,
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, `Provider request failed with HTTP ${response.status}`), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});

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

@@ -1,4 +1,7 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { ProviderOAuthRuntime } from "../../oauth/oauth-token.ts";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+/** Feishu's refresh errors distinguish expired tokens from client configuration failures. */
+export declare const oauth: ProviderOAuthRuntime;

package/src/providers/feishu/executors.js

@@ -1,5 +1,6 @@
-import { optionalString } from "../../core/cast.js";
-import { defineOAuthProviderExecutors, defineProviderProxy, getProviderActionHandler, mapProviderActionHandlers, ProviderRequestError, } from "../provider-runtime.js";
+import { optionalNumber, optionalString } from "../../core/cast.js";
+import { expiresAtFromLifetime } from "../../oauth/oauth-token.js";
+import { defineOAuthProviderExecutors, defineProviderProxy, getProviderActionHandler, mapProviderActionHandlers, ProviderRequestError, readProviderJsonBody, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
 import { feishuActions } from "./actions.js";
 import { feishuActionHandlers, feishuOpenBaseUrl, fetchFeishuUserInfo } from "./runtime.js";
 import { createFeishuApplicationActionHandlers } from "./shared/application-runtime.js";
@@ -138,3 +139,47 @@ export const credentialValidators = {
         };
     },
 };
+const expiredRefreshTokenCodes = new Set([20037, 20064, 20073]);
+/** Feishu's refresh errors distinguish expired tokens from client configuration failures. */
+export const oauth = {
+    async refreshAccessToken(input) {
+        const { payload, ok, status } = await runProviderRequest({ label: "Feishu OAuth refresh" }, async (signal) => {
+            const response = await input.fetcher("https://open.feishu.cn/open-apis/authen/v2/oauth/token", {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    grant_type: "refresh_token",
+                    client_id: input.clientConfig.clientId,
+                    client_secret: input.clientConfig.clientSecret,
+                    refresh_token: input.refreshToken,
+                }),
+                redirect: "manual",
+                signal,
+            });
+            const payload = requiredResponseRecord(await readProviderJsonBody(response, {
+                maxBytes: 1024 * 1024,
+                emptyBody: {},
+                invalidJsonMessage: "Feishu returned invalid token JSON",
+            }), "Feishu token response");
+            return { payload, ok: response.ok, status: response.status };
+        });
+        const code = optionalNumber(payload.code);
+        if (!ok || (code !== undefined && code !== 0)) {
+            const message = `Feishu ${code ?? status}: ${optionalString(payload.error_description) ?? optionalString(payload.msg) ?? optionalString(payload.error) ?? "Token request failed"}`;
+            if (code !== undefined && expiredRefreshTokenCodes.has(code))
+                throw input.createError(message);
+            throw new ProviderRequestError(ok ? 400 : status, message, undefined, "provider_error");
+        }
+        const accessToken = optionalString(payload.access_token);
+        if (!accessToken)
+            throw new ProviderRequestError(502, "Feishu token response is missing access_token", undefined, "provider_error");
+        const { access_token: _accessToken, refresh_token: _refreshToken, ...metadata } = payload;
+        return {
+            accessToken,
+            refreshToken: optionalString(payload.refresh_token),
+            tokenType: optionalString(payload.token_type) ?? "Bearer",
+            expiresAt: expiresAtFromLifetime(payload.expires_in),
+            metadata,
+        };
+    },
+};

package/src/providers/feishu/runtime.js

@@ -176,7 +176,9 @@ async function feishuApiRequest(input) {
     if (!response.ok || code !== 0) {
         const message = optionalString(envelope.msg) ?? `Feishu request failed (HTTP ${response.status}).`;
         const status = mapFeishuErrorStatus(response.status, code);
-        throw new ProviderRequestError(status, code ? `Feishu ${code}: ${message}` : message);
+        throw new ProviderRequestError(status, code ? `Feishu ${code}: ${message}` : message, undefined, feishuCredentialErrorCodes.has(code) || feishuScopeErrorCodes.has(code)
+            ? "authorization_failed"
+            : "provider_error");
     }
     const data = optionalRecord(envelope.data);
     if (!data) {
@@ -210,7 +212,7 @@ function normalizeFeishuPage(data) {
     };
 }
 function mapFeishuErrorStatus(httpStatus, code) {
-    if (httpStatus === 401 || feishuCredentialErrorCodes.has(code)) {
+    if (feishuCredentialErrorCodes.has(code)) {
         return 401;
     }
     if (httpStatus === 403 || feishuScopeErrorCodes.has(code)) {

package/src/providers/feishu/shared/client.js

@@ -4,7 +4,7 @@ const feishuOpenBaseUrl = "https://open.feishu.cn/open-apis";
 const feishuRateLimitedErrorCodes = new Set([11232, 11233, 11247, 230020, 230047, 99991400, 1000004, 1000005]);
 const feishuCredentialExpiredErrorCodes = new Set([
     4001, 10005, 10012, 10013, 10014, 10015, 20002, 20005, 20013, 20014, 99991543, 99991661, 99991663, 99991664, 99991665,
-    99991671, 99991673,
+    99991668, 99991671, 99991677,
 ]);
 const feishuScopeMissingErrorCodes = new Set([10023, 11223, 11229, 11241, 99991672, 99991676, 99991679]);
 export function createFeishuJsonRequest(input) {
@@ -196,8 +196,8 @@ function normalizeFeishuError(input) {
             return new ProviderRequestError(400, detailedMessage, errorData);
         }
     }
-    if (input.status === 401 || (code != null && feishuCredentialExpiredErrorCodes.has(code))) {
-        return new ProviderRequestError(401, detailedMessage, errorData);
+    if (code != null && feishuCredentialExpiredErrorCodes.has(code)) {
+        return new ProviderRequestError(401, detailedMessage, errorData, "authorization_failed");
     }
     if (code != null && feishuScopeMissingErrorCodes.has(code)) {
         return new ProviderRequestError(403, detailedMessage, errorData);
@@ -205,5 +205,5 @@ function normalizeFeishuError(input) {
     if (input.status === 400 || input.status === 404 || input.status === 422 || code === 230001) {
         return new ProviderRequestError(input.status || 400, detailedMessage, errorData);
     }
-    return new ProviderRequestError(502, detailedMessage, errorData);
+    return new ProviderRequestError(input.status >= 400 ? input.status : 502, detailedMessage, errorData, "provider_error");
 }

package/src/providers/feishu/shared/docs-actions.js

@@ -27,6 +27,13 @@ const documentOutputSchema = s.object("A Feishu document operation result.", {
 }, {
     optional: [],
 });
+const creationOutputSchema = s.requiredObject("The document creation status and result.", {
+    taskId: s.nullable(s.string("The task ID to poll; null when creation completed synchronously.")),
+    status: s.stringEnum("The document creation state.", ["processing", "succeeded", "failed", "expired"]),
+    document: s.nullable(looseDocumentSchema),
+    pollAfterMs: s.nullable(s.integer("The suggested delay before the next status request.")),
+    failure: s.nullable(s.looseObject("The upstream failure code and message, if creation failed.")),
+});
 const taskOutputSchema = s.looseRequiredObject("A Feishu document background task result.", {
     taskId: s.string("The task ID used to query the operation status."),
     status: s.string("The current task status."),
@@ -40,6 +47,10 @@ export function createFeishuDocsActions(service) {
     return [
         defineProviderAction(service, {
             name: "create_document",
+            asyncLifecycle: {
+                startActionId: `${service}.create_document`,
+                statusActionId: `${service}.get_document_creation`,
+            },
             operationType: "write",
             description: "Create a Feishu document from Docx XML or Markdown content, optionally inside a folder or Wiki node.",
             requiredScopes: [feishuDocsProviderScopes.create],
@@ -58,7 +69,22 @@ export function createFeishuDocsActions(service) {
             }, {
                 optional: ["title", "format", "parentToken", "parentPosition", "referenceMap"],
             }),
-            outputSchema: documentOutputSchema,
+            outputSchema: creationOutputSchema,
+        }),
+        defineProviderAction(service, {
+            name: "get_document_creation",
+            operationType: "read",
+            description: "Get a document creation task status and its completed document. Do not repeat creation while the task is processing.",
+            requiredScopes: [feishuDocsProviderScopes.create],
+            providerPermissions: [feishuDocsProviderScopes.create],
+            asyncLifecycle: {
+                startActionId: `${service}.create_document`,
+                statusActionId: `${service}.get_document_creation`,
+            },
+            inputSchema: s.requiredObject("Identify the document creation task.", {
+                taskId: s.nonEmptyString("The task ID returned by create_document."),
+            }),
+            outputSchema: creationOutputSchema,
         }),
         defineProviderAction(service, {
             name: "fetch_document",

package/src/providers/feishu/shared/docs-runtime.js

@@ -1,11 +1,16 @@
-import { optionalNumber, optionalRecord, optionalStringArray } from "../../../core/cast.js";
-import { providerInputError } from "../../provider-runtime.js";
+import { optionalNumber, optionalRecord, optionalRawString, optionalStringArray, requiredString, } from "../../../core/cast.js";
+import { providerInputError, ProviderRequestError, requiredResponseRecord } from "../../provider-runtime.js";
 const docsExtraParam = '{"enable_user_cite_reference_map":true,"return_html5_block_data":true}';
 export function createFeishuDocsActionHandlers(request) {
     return {
         create_document(input) {
             return createDocument(input, request);
         },
+        async get_document_creation(input) {
+            const taskId = requireString(input.taskId, "taskId");
+            const data = await request({ path: `/docs_ai/v1/async_tasks/${encodeURIComponent(taskId)}` });
+            return normalizeCreation(data, taskId);
+        },
         fetch_document(input) {
             return fetchDocument(input, request);
         },
@@ -40,13 +45,59 @@ async function createDocument(input, request) {
         path: "/docs_ai/v1/documents",
         body: {
             format,
+            extra_param: '{"open_create_async":true}',
             content: title ? `${createTitle(format, title)}\n${content}` : content,
             parent_token: parentToken,
             parent_position: parentPosition,
             reference_map: optionalRecord(input.referenceMap),
         },
     });
-    return { document: optionalRecord(data.document) ?? data };
+    return normalizeCreation(data);
+}
+function normalizeCreation(data, expectedTaskId) {
+    if (data.task == null && !expectedTaskId) {
+        return {
+            taskId: null,
+            status: "succeeded",
+            document: requireCreatedDocument(data.document),
+            pollAfterMs: null,
+            failure: null,
+        };
+    }
+    const task = requiredResponseRecord(data.task, "Feishu document creation task");
+    const taskId = optionalRawString(task.task_id) || expectedTaskId;
+    if (!taskId || (expectedTaskId && taskId !== expectedTaskId)) {
+        throw new ProviderRequestError(502, "Feishu document creation task ID is missing or mismatched");
+    }
+    const status = optionalRawString(task.status)?.trim().toLowerCase() || "processing";
+    if (!["processing", "succeeded", "failed", "expired"].includes(status)) {
+        throw new ProviderRequestError(502, `Unsupported Feishu document creation status: ${status}`);
+    }
+    let document = null;
+    if (status === "succeeded") {
+        const result = optionalRecord(task.result);
+        const serialized = optionalRawString(result?.create_document);
+        let parsed;
+        try {
+            parsed = JSON.parse(serialized ?? "");
+        }
+        catch {
+            throw new ProviderRequestError(502, "Invalid Feishu document creation result JSON");
+        }
+        document = requireCreatedDocument(optionalRecord(parsed)?.document);
+    }
+    return {
+        taskId,
+        status,
+        document,
+        pollAfterMs: optionalNumber(task.poll_after_ms) ?? null,
+        failure: optionalRecord(task.failure) ?? null,
+    };
+}
+function requireCreatedDocument(value) {
+    const document = requiredResponseRecord(value, "Feishu created document");
+    requiredString(document.document_id, "Feishu created document.document_id", (message) => new ProviderRequestError(502, message));
+    return document;
 }
 async function fetchDocument(input, request) {
     const documentId = requireString(input.documentId, "documentId");

package/src/providers/feishu/shared/domain-media-runtime.js

@@ -566,7 +566,7 @@ async function resolveSlidesPresentation(input, request) {
         return token;
     }
     const data = await request({
-        path: "/wiki/v2/spaces/get_node",
+        path: "/wiki/v2/spaces/node_by_token",
         query: { token },
     });
     const node = optionalRecord(data.node);

package/src/providers/feishu/shared/drive-runtime.js

@@ -64,7 +64,7 @@ async function inspectDriveItem(input, request) {
     let wikiNode = undefined;
     if (type === "wiki") {
         const wikiData = await request({
-            path: "/wiki/v2/spaces/get_node",
+            path: "/wiki/v2/spaces/node_by_token",
             query: { token },
         });
         wikiNode = optionalRecord(wikiData.node);

package/src/providers/feishu/shared/slides-runtime.js

@@ -252,7 +252,7 @@ async function resolvePresentationId(input, request) {
         return token;
     }
     const data = await request({
-        path: "/wiki/v2/spaces/get_node",
+        path: "/wiki/v2/spaces/node_by_token",
         query: { token },
     });
     const node = optionalRecord(data.node);

package/src/providers/feishu/shared/vc-actions.js

@@ -4,7 +4,7 @@ const meetingId = s.string("The Feishu video meeting ID.", { minLength: 1 });
 const raw = s.looseObject("The raw video-conference object returned by Feishu.");
 export function createFeishuVcActions(options) {
     const queryPermission = options.identity === "user" ? "vc:meeting.meetingevent:read" : "vc:meeting.bot.join:write";
-    return [
+    const actions = [
         defineProviderAction(options.service, {
             name: "join_vc_meeting",
             operationType: "write",
@@ -16,12 +16,16 @@ export function createFeishuVcActions(options) {
                     minLength: 9,
                     maxLength: 9,
                 }),
+                action: s.stringEnum("Join an active meeting or start a Calendar meeting; defaults to join.", [
+                    "join",
+                    "start",
+                ]),
                 password: s.string("The meeting password, when required.", { minLength: 1 }),
                 callId: s.string("The correlation ID forwarded by a meeting invite event.", {
                     minLength: 1,
                 }),
             }, {
-                optional: ["password", "callId"],
+                optional: ["action", "password", "callId"],
             }),
             outputSchema: s.object("The joined meeting.", {
                 meeting: raw,
@@ -112,4 +116,7 @@ export function createFeishuVcActions(options) {
             }),
         }),
     ];
+    return options.identity === "tenant"
+        ? actions
+        : actions.filter((action) => !["join_vc_meeting", "leave_vc_meeting"].includes(action.name));
 }

package/src/providers/feishu/shared/vc-runtime.js

@@ -27,6 +27,7 @@ async function joinMeeting(input, request) {
         method: "POST",
         path: "/vc/v1/bots/join",
         body: {
+            action: optionalString(input.action) ?? "join",
             join_type: 1,
             join_identify: { meeting_no: meetingNumber },
             password: optionalString(input.password),

package/src/providers/feishu/shared/wiki-actions.js

@@ -100,16 +100,15 @@ export function createFeishuWikiActions(service) {
         defineProviderAction(service, {
             name: "get_wiki_node",
             operationType: "read",
-            description: "Resolve and get a Feishu Wiki node by token and object type.",
+            description: "Resolve a Feishu Wiki node by node token or document token; the server detects the token type.",
             // Feishu refuses `wiki:node:retrieve` for this endpoint with 99991679
             // and names `wiki:node:read` as the narrow accepted permission.
             requiredScopes: ["wiki:node:read"],
             providerPermissions: ["wiki:node:read"],
             inputSchema: s.object("Identify the Wiki node.", {
                 token: s.string("A Wiki node_token or document obj_token.", { minLength: 1 }),
-                objectType,
             }, {
-                optional: ["objectType"],
+                optional: [],
             }),
             outputSchema: itemOutput,
         }),

package/src/providers/feishu/shared/wiki-runtime.js

@@ -92,10 +92,9 @@ async function listNodes(input, request) {
 }
 async function getNode(input, request) {
     const data = await request({
-        path: "/wiki/v2/spaces/get_node",
+        path: "/wiki/v2/spaces/node_by_token",
         query: {
             token: requiredString(input.token, "token"),
-            obj_type: optionalString(input.objectType),
         },
     });
     return { item: recordValue(data.node) };

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor, TransitFileWriter } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlerSubset } from "../provider-runtime.ts";
 interface FeishuAppBotCredential {
     appId: string;
@@ -16,4 +18,5 @@ export declare const feishuAppBotActionHandlers: ProviderActionHandlerSubset<"fe
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};