@oomol-lab/open-connector 1.6.3 → 1.6.5

package/src/providers/slack/actions.js

@@ -537,6 +537,23 @@ export const slackActions = [
         inputSchema: s.object({ fileId: fileIdSchema }, { required: ["fileId"], description: "Input parameters for fetching a Slack file." }),
         outputSchema: s.object({ file: fileSchema }, { required: ["file"], description: "The output payload for this action." }),
     }),
+    action({
+        name: "download_file",
+        operationType: "read",
+        description: "Download a Slack-hosted file into transit storage using the connected identity's access.",
+        requiredScopes: ["files:read"],
+        inputSchema: s.requiredObject("The Slack file to download.", { fileId: fileIdSchema }),
+        outputSchema: s.requiredObject("A Slack file downloaded into transit storage.", {
+            fileId: fileIdSchema,
+            file: s.requiredObject("The downloaded file in transit storage.", {
+                fileId: s.nonEmptyString("The transit file identifier."),
+                downloadUrl: s.url("The transit URL for downloading the stored file."),
+                sizeBytes: s.nonNegativeInteger("The stored file size in bytes."),
+                name: s.nonEmptyString("The stored file name."),
+                mimeType: s.nonEmptyString("The stored file MIME type."),
+            }),
+        }),
+    }),
     action({
         name: "delete_file",
         operationType: "destructive",

package/src/providers/slack/runtime.js

@@ -1,6 +1,6 @@
-import { compactObject, optionalBoolean, optionalInteger, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
+import { compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
 import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
-import { createProviderTimeout, defineProviderExecutors, isAbortLikeError, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
+import { createProviderTimeout, defineProviderExecutors, isAbortLikeError, ProviderRequestError, providerInputError, providerResponseError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
 import { slackConversationTypes } from "./constants.js";
 export const slackApiBaseUrl = "https://slack.com/api";
 const slackFileUrlMaxBytes = 100 * 1024 * 1024;
@@ -116,6 +116,9 @@ export const slackActionHandlers = {
     get_file(input, context) {
         return slackGetFile(input, context);
     },
+    download_file(input, context) {
+        return slackDownloadFile(input, context);
+    },
     delete_file(input, context) {
         return slackDeleteFile(input, context);
     },
@@ -545,6 +548,61 @@ async function slackGetFile(input, context) {
         file: normalizeFile(payload.file ?? {}),
     };
 }
+async function slackDownloadFile(input, context) {
+    const { transitFiles } = context;
+    if (!transitFiles) {
+        throw providerInputError("Slack download_file requires transit file storage");
+    }
+    const fileId = requiredInputString(input.fileId, "fileId");
+    return runProviderRequest({ signal: context.signal, label: "Slack file download" }, async (signal) => {
+        signal.throwIfAborted();
+        const infoUrl = slackApiUrl("files.info");
+        infoUrl.searchParams.set("file", fileId);
+        const payload = await slackGetJson(infoUrl, { ...context, signal });
+        const metadata = requiredResponseRecord(payload.file, "Slack file metadata");
+        const privateUrl = optionalString(metadata.url_private_download) ?? optionalString(metadata.url_private);
+        if (metadata.is_external === true || !privateUrl) {
+            throw providerInputError("This Slack file has no downloadable Slack-hosted content");
+        }
+        const url = assertPublicHttpUrl(privateUrl, { fieldName: "Slack file URL", createError: providerResponseError });
+        // Only Slack's file origin may receive the connection's bearer token.
+        // The shared fetch guard drops it if a redirect crosses origins.
+        if (url.origin !== "https://files.slack.com") {
+            throw providerResponseError("Slack file URL must use https://files.slack.com");
+        }
+        if ((optionalNumber(metadata.size) ?? 0) > transitFiles.maxBytes) {
+            throw new ProviderRequestError(413, `Slack file download exceeds ${transitFiles.maxBytes} bytes`);
+        }
+        const response = await context.fetcher(url, {
+            headers: { authorization: `Bearer ${context.accessToken}`, "user-agent": providerUserAgent },
+            signal,
+        });
+        try {
+            if (!response.ok) {
+                throw new ProviderRequestError(response.status, `Slack file download failed with HTTP ${response.status}`);
+            }
+            const mimeType = optionalString(response.headers.get("content-type")) ??
+                optionalString(metadata.mimetype) ??
+                "application/octet-stream";
+            // Slack can return a sign-in page instead of the requested bytes.
+            if (mimeType.split(";")[0]?.trim().toLowerCase() === "text/html" && metadata.mimetype !== "text/html") {
+                throw providerResponseError("Slack returned an HTML page instead of the requested file");
+            }
+            const bytes = await readBoundedResponseBytes(response, {
+                maxBytes: transitFiles.maxBytes,
+                fieldName: "Slack file download",
+                createError: (message) => new ProviderRequestError(413, message),
+            });
+            signal.throwIfAborted();
+            const name = optionalString(metadata.name) ?? fileId;
+            const file = await transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
+            return { fileId, file };
+        }
+        finally {
+            await response.body?.cancel().catch(() => undefined);
+        }
+    });
+}
 async function slackDeleteFile(input, context) {
     await slackRequestJson({
         ...context,
@@ -688,10 +746,10 @@ function readSlackTokenKind(accessToken, metadata) {
     if (rawTokenType == "user") {
         return "user";
     }
-    if (accessToken.startsWith("xoxb-")) {
+    if (accessToken.startsWith("xoxb-") || accessToken.startsWith("xoxe.xoxb-")) {
         return "bot";
     }
-    if (accessToken.startsWith("xoxp-")) {
+    if (accessToken.startsWith("xoxp-") || accessToken.startsWith("xoxe.xoxp-")) {
         return "user";
     }
     return undefined;

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

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

package/src/providers/speak_ai/executors.js

@@ -0,0 +1,187 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { compactObject, looseArray, optionalInteger, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, readProviderJsonBody, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const service = "speak_ai";
+const apiBaseUrl = "https://api.speakai.co/v1";
+const tokenCache = new Map();
+const handlers = {
+    async upload_media(input, context) {
+        const data = await request("/media/upload", {
+            method: "POST",
+            body: compactObject({
+                name: requiredInputString(input.name, "name"),
+                url: requiredInputString(input.mediaUrl, "mediaUrl"),
+                mediaType: optionalString(input.mediaType),
+                description: optionalString(input.description),
+                sourceLanguage: optionalString(input.sourceLanguage),
+                tags: optionalString(input.tags),
+                folderId: optionalString(input.folderId),
+            }),
+        }, context, "execute");
+        return { mediaId: requiredResponseString(data.mediaId, "Speak AI upload mediaId") };
+    },
+    async list_media(input, context) {
+        const data = await request(buildUrl("/media", input, {
+            mediaType: "mediaType",
+            page: "page",
+            pageSize: "pageSize",
+            sortBy: "sortBy",
+            filterMedia: "filterMedia",
+            filterName: "filterName",
+            folderId: "folderId",
+        }), { method: "GET" }, context, "execute");
+        return {
+            totalCount: requireInteger(data.totalCount, "totalCount"),
+            pages: requireInteger(data.pages, "pages"),
+            media: looseArray(data.mediaList),
+        };
+    },
+    async get_media_status(input, context) {
+        const data = await media(input, context, "status");
+        return {
+            mediaId: requiredResponseString(data.mediaId, "mediaId"),
+            state: requiredResponseString(data.state, "state"),
+            media: data,
+        };
+    },
+    async get_transcript(input, context) {
+        const data = await media(input, context, "transcript");
+        return { mediaId: requiredResponseString(data.mediaId, "mediaId"), transcript: data };
+    },
+    async get_media_insights(input, context) {
+        const data = await media(input, context, "insight");
+        return { mediaId: requiredResponseString(data.mediaId, "mediaId"), insights: data };
+    },
+    async list_folders(input, context) {
+        const data = await request(buildUrl("/folder", input, { page: "page", pageSize: "pageSize", sortBy: "sortBy" }), { method: "GET" }, context, "execute");
+        return {
+            totalCount: requireInteger(data.totalCount, "totalCount"),
+            pages: data.pages == null ? null : requireInteger(data.pages, "pages"),
+            folders: looseArray(data.folders),
+        };
+    },
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        const token = await authenticate(input.apiKey, fetcher, "validate");
+        return {
+            profile: { accountId: token.email ?? "speak-ai-api-key", displayName: token.email ?? "Speak AI API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl, validationEndpoint: "/auth/accessToken" },
+        };
+    },
+};
+async function media(input, context, family) {
+    const mediaId = requiredInputString(input.mediaId, "mediaId");
+    const data = await request(`/media/${family}/${encodeURIComponent(mediaId)}`, { method: "GET" }, context, "execute");
+    return data.state === "notUploaded" && data.mediaId === undefined ? { ...data, mediaId } : data;
+}
+async function request(path, init, context, phase) {
+    let token = await authenticate(context.apiKey, context.fetcher, phase);
+    let response = await fetchToken(path, init, context, token.accessToken);
+    let payload = await readProviderJsonBody(response, {
+        emptyBody: {},
+        invalidJsonMessage: "Speak AI returned invalid JSON",
+    });
+    if (phase === "execute" && response.status === 401) {
+        tokenCache.delete(sha256Hex(context.apiKey));
+        token = await authenticate(context.apiKey, context.fetcher, phase);
+        response = await fetchToken(path, init, context, token.accessToken);
+        payload = await readProviderJsonBody(response, {
+            emptyBody: {},
+            invalidJsonMessage: "Speak AI returned invalid JSON",
+        });
+    }
+    if (!response.ok)
+        throw error(response.status, payload, phase);
+    const envelope = requiredResponseRecord(payload, "Speak AI response");
+    if (envelope.state === "notUploaded" && envelope.data === undefined)
+        return envelope;
+    return requiredResponseRecord(envelope.data, "Speak AI response data");
+}
+function requiredResponseString(value, label) {
+    const result = optionalString(value);
+    if (!result)
+        throw providerResponseError(`${label} must be a non-empty string`);
+    return result;
+}
+function fetchToken(path, init, context, accessToken) {
+    return runProviderRequest({ signal: context.signal, label: "Speak AI" }, (signal) => context.fetcher(path instanceof URL ? path : `${apiBaseUrl}${path}`, {
+        method: init.method,
+        headers: {
+            accept: "application/json",
+            "content-type": "application/json",
+            "user-agent": providerUserAgent,
+            "x-speakai-key": context.apiKey,
+            "x-access-token": accessToken,
+        },
+        body: init.body ? JSON.stringify(init.body) : undefined,
+        signal,
+    }));
+}
+async function authenticate(apiKey, fetcher, phase) {
+    const key = sha256Hex(apiKey);
+    if (phase === "validate")
+        tokenCache.delete(key);
+    const cached = tokenCache.get(key);
+    if (cached) {
+        const value = await cached;
+        if (Date.now() < value.expiresAt)
+            return value;
+        tokenCache.delete(key);
+    }
+    const pending = runProviderRequest({ label: "Speak AI authentication" }, async (signal) => {
+        const response = await fetcher(`${apiBaseUrl}/auth/accessToken`, {
+            method: "POST",
+            headers: { "content-type": "application/json", "user-agent": providerUserAgent, "x-speakai-key": apiKey },
+            body: "{}",
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: {},
+            invalidJsonMessage: "Speak AI returned invalid JSON",
+        });
+        if (!response.ok)
+            throw error(response.status, payload, phase);
+        const data = requiredResponseRecord(requiredResponseRecord(payload, "Speak AI authentication response").data, "Speak AI authentication data");
+        return {
+            accessToken: requiredInputString(data.accessToken, "accessToken"),
+            email: optionalString(data.email),
+            expiresAt: Date.now() + 3_000_000,
+        };
+    });
+    tokenCache.set(key, pending);
+    try {
+        return await pending;
+    }
+    catch (cause) {
+        tokenCache.delete(key);
+        throw cause;
+    }
+}
+function error(status, payload, phase) {
+    const body = requiredResponseRecord(payload, "Speak AI error response");
+    const message = optionalString(body.message) ?? "Speak AI request failed";
+    if (status === 429)
+        return new ProviderRequestError(429, message, payload);
+    if (phase === "validate" && optionalInteger(body.code) === 401)
+        return providerInputError(message);
+    if (status === 400 || status === 422)
+        return providerInputError(message);
+    return new ProviderRequestError(status || 502, message, payload);
+}
+function requireInteger(value, label) {
+    if (typeof value !== "number" || !Number.isInteger(value))
+        throw new ProviderRequestError(502, `Speak AI ${label} must be an integer`);
+    return value;
+}
+function buildUrl(path, input, mapping) {
+    const url = new URL(`${apiBaseUrl}${path}`);
+    for (const [key, query] of Object.entries(mapping))
+        if (input[key] != null)
+            url.searchParams.set(query, String(input[key]));
+    return url;
+}

package/src/providers/tongdaxin/executors.js

@@ -20,7 +20,7 @@ const handlers = {
         if (!argumentsValue)
             throw new ProviderRequestError(400, "arguments must be a JSON object");
         assertToolArgumentsSize(argumentsValue);
-        const result = await withTongdaxinClient(context, "execute", (client) => client.callTool({ name: toolName, arguments: argumentsValue }, { timeout: requestTimeoutMs, signal: context.signal }));
+        const result = await withTongdaxinClient(context, "execute", false, (client) => client.callTool({ name: toolName, arguments: argumentsValue }, { timeout: requestTimeoutMs, signal: context.signal }));
         if (!("toolResult" in result) && result.isError) {
             throw new ProviderRequestError(502, `Tongdaxin MCP tool ${toolName} returned an error`, result);
         }
@@ -48,7 +48,7 @@ for (const actionName of Object.keys(resolveNamedHandlers())) {
                 tool.annotations.destructiveHint === true)) {
             throw new ProviderRequestError(403, `Tongdaxin MCP does not currently affirm ${tool.name} as a non-destructive read-only tool`);
         }
-        const result = await withTongdaxinClient(context, "execute", (client) => client.callTool({ name: toolCall.toolName, arguments: toolCall.arguments }, { timeout: requestTimeoutMs, signal: context.signal }));
+        const result = await withTongdaxinClient(context, "execute", true, (client) => client.callTool({ name: toolCall.toolName, arguments: toolCall.arguments }, { timeout: requestTimeoutMs, signal: context.signal }));
         if (!("toolResult" in result) && result.isError) {
             throw new ProviderRequestError(502, `Tongdaxin MCP tool ${toolCall.toolName} returned an error`, result);
         }
@@ -78,7 +78,7 @@ export const credentialValidators = {
     },
 };
 async function discoverSupportedTools(context, phase) {
-    const result = await withTongdaxinClient(context, phase, (client) => client.listTools({}, { timeout: requestTimeoutMs, signal: context.signal }));
+    const result = await withTongdaxinClient(context, phase, true, (client) => client.listTools({}, { timeout: requestTimeoutMs, signal: context.signal }));
     return result.tools.map((tool) => ({
         name: tool.name,
         description: tool.description,
@@ -86,7 +86,7 @@ async function discoverSupportedTools(context, phase) {
         inputSchema: tool.inputSchema,
     }));
 }
-async function withTongdaxinClient(context, phase, run) {
+async function withTongdaxinClient(context, phase, retryOnSessionNotFound, run) {
     return withMcpClient({
         endpoint,
         transport: "streamable_http",
@@ -97,6 +97,7 @@ async function withTongdaxinClient(context, phase, run) {
         },
         redirect: "error",
         signal: context.signal,
+        retryOnSessionNotFound,
         mapError: (error) => mapTongdaxinError(error, phase),
     }, run);
 }

package/src/providers/tongdaxin/named-action-output.js

@@ -40,7 +40,7 @@ export function normalizeTongdaxinNamedActionOutput(actionName, result) {
         case "get_board_and_industry_data":
         case "get_hot_topics":
         case "get_hk_financials":
-            return normalizeF10(resultObject, result);
+            return normalizeF10(resultObject);
         default:
             return assertNever(actionName);
     }
@@ -103,15 +103,9 @@ function normalizeSearch(resultObject, result) {
         result,
     };
 }
-function normalizeF10(resultObject, result) {
+function normalizeF10(resultObject) {
     const response = requiredResponseRecord(resultObject.response, "Tongdaxin F10 response");
-    const transformed = requiredResponseRecord(response.transformed, "Tongdaxin F10 transformed data");
-    return {
-        ok: optionalBoolean(resultObject.ok) ?? optionalBoolean(response.ok) ?? null,
-        summary: asStringOrNull(transformed.summary ?? resultObject.summary),
-        tables: requireResponseObjectArray(transformed.tables, "Tongdaxin F10 tables"),
-        result,
-    };
+    return response.transformed ?? null;
 }
 function assertNever(value) {
     throw providerResponseError(`unhandled Tongdaxin action output: ${value}`);

package/src/providers/tongdaxin/named-action-routing.js

@@ -295,7 +295,7 @@ function capitalAndTradingArguments(input) {
                 extra: input.date,
             };
         case "BLOCK_TRADE_INTENTION":
-            return dataSection("TdxSharePCCW.tdxf10_gg_iyds", code, "yxsbxx");
+            return dataSection("TdxSharePCCW.tdxf10_gg_jyds", code, "yxsbxx");
         case "MARGIN_TRADING":
             return dataSection("TdxSharePCCW.tdxf10_gg_jyds", code, "rzrq");
         case "REFINANCING":

package/src/providers/tongdaxin/named-actions.js

@@ -62,12 +62,7 @@ const searchOutputSchema = s.object("A normalized Tongdaxin current-information
     data: s.nullable(s.unknown("The provider-defined search rows returned by Wenda, or null when unavailable.")),
     result: rawResultSchema,
 });
-const f10OutputSchema = s.object("A normalized Tongdaxin F10 result.", {
-    ok: s.nullableBoolean("Whether the underlying F10 request reported success."),
-    summary: s.nullableString("The structured result summary, or null when unavailable."),
-    tables: s.array("The formatted F10 result tables.", looseRowSchema),
-    result: rawResultSchema,
-});
+const f10OutputSchema = s.unknown("The transformed F10 data returned by Tongdaxin, preserved as any JSON value.");
 function defineReadAction(name, description, inputSchema, outputSchema = f10OutputSchema) {
     return defineProviderAction(service, {
         name,

package/src/providers/tushare/runtime.js

@@ -234,12 +234,18 @@ export const tushareActionHandlers = {
     },
 };
 export async function validateTushareCredential(apiKey, fetcher, signal) {
-    const payload = await tushareRequest({
-        apiName: "trade_cal",
-        params: { exchange: "", start_date: "20180901", end_date: "20180902" },
-        fields: "exchange,cal_date,is_open",
-    }, { apiKey, fetcher, signal });
-    normalizeTableData(payload.data);
+    try {
+        const payload = await tushareRequest({
+            apiName: "daily",
+            params: { ts_code: "000001.SZ", trade_date: "20180903" },
+            fields: "ts_code,trade_date",
+        }, { apiKey, fetcher, signal });
+        normalizeTableData(payload.data);
+    }
+    catch (error) {
+        if (!(error instanceof ProviderRequestError) || error.status !== 403)
+            throw error;
+    }
     return {
         profile: {
             accountId: "tushare-token",
@@ -248,7 +254,7 @@ export async function validateTushareCredential(apiKey, fetcher, signal) {
         grantedScopes: [],
         metadata: {
             apiBaseUrl: tushareApiBaseUrl,
-            validationApiName: "trade_cal",
+            validationApiName: "daily",
             credentialHelpUrl: "https://tushare.pro/document/1?doc_id=39",
         },
     };
@@ -333,8 +339,10 @@ async function readJsonPayload(response) {
 }
 function createTushareHttpError(status, payload) {
     const message = extractErrorMessage(payload) ?? `Tushare request failed with ${status || 500}`;
-    if (status === 401 || status === 403)
+    if (status === 401)
         return new ProviderRequestError(400, message, payload);
+    if (status === 403)
+        return new ProviderRequestError(403, message, payload);
     if (status === 429)
         return new ProviderRequestError(429, message, payload);
     return new ProviderRequestError(status || 502, message, payload);
@@ -343,12 +351,17 @@ function createTushareApiError(code, payload) {
     const message = `Tushare request failed: ${extractErrorMessage(payload) ?? `code ${code}`}`;
     if (code === 40101)
         return new ProviderRequestError(400, message, payload);
-    if (code === 2002)
+    if (isTusharePermissionError(code, message))
         return new ProviderRequestError(403, message, payload);
     if (code === 2003 || code === 2004 || message.includes("频率超限"))
         return new ProviderRequestError(429, message, payload);
     return new ProviderRequestError(502, message, payload);
 }
+function isTusharePermissionError(code, message) {
+    return (code === 2002 ||
+        message.includes("没有权限访问该接口") ||
+        (message.includes("没有接口(") && message.includes("访问权限")));
+}
 function normalizeTableData(value) {
     const data = requiredResponseRecord(value, "data");
     return {

package/src/providers/twenty_crm/runtime.js

@@ -57,9 +57,10 @@ async function listMetadataObjects(context, phase = "execute") {
     };
 }
 async function listRecords(input, context) {
+    const objectNamePlural = readRequiredString(input.objectNamePlural, "objectNamePlural");
     const payload = await requestTwentyCrmJson({
         method: "GET",
-        path: `/rest/${encodeObjectName(readRequiredString(input.objectNamePlural, "objectNamePlural"))}`,
+        path: `/rest/${encodeObjectName(objectNamePlural)}`,
         query: compactObject({
             limit: optionalInteger(input.limit),
             starting_after: readOptionalString(input.startingAfter),
@@ -70,8 +71,9 @@ async function listRecords(input, context) {
         }),
     }, context);
     const record = requireProviderObject(payload, "Twenty CRM list records response");
+    const data = requireProviderObject(record.data, "Twenty CRM data");
     return {
-        records: readArray(record, "data").map((item) => requireProviderObject(item, "Twenty CRM record")),
+        records: readArray(data, objectNamePlural).map((item) => requireProviderObject(item, "Twenty CRM record")),
         pageInfo: optionalRecord(record.pageInfo) ?? {},
         raw: record,
     };

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

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