@oomol-lab/open-connector 1.6.3 → 1.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oomol-lab/open-connector",
-  "version": "1.6.3",
+  "version": "1.6.4",
   "description": "Embeddable Open Connector runtime for Node.js and Bun.",
   "license": "Apache-2.0",
   "type": "module",

package/src/providers/dropbox/executors.js

@@ -209,6 +209,24 @@ async function getMetadata(input, accessToken, fetcher) {
         metadata: mapDropboxMetadata(payload),
     };
 }
+/**
+ * Serialize a `Dropbox-API-Arg` header value.
+ *
+ * Dropbox requires this header to be ASCII: its own docs say `0x7F` and every
+ * non-ASCII character must be escaped as `\uXXXX`, which is also the range the
+ * official JS SDK escapes. `JSON.stringify` does not escape, and Node's `Headers`
+ * refuses a value outside ByteString, so a path containing any non-ASCII
+ * character threw `TypeError: Cannot convert argument to a ByteString` inside
+ * the runtime BEFORE the request was made. `provider-runtime.ts`'s fallback
+ * then reported it as a bare `internal_error`, discarding the cause.
+ *
+ * Measured 2026-09-18 against a real account: `/kkndme 天涯.pdf` failed in 1ms
+ * with no network call, while ASCII-path siblings downloaded in ~400ms. Dropbox
+ * itself accepts either spelling on the wire; only the header build was broken.
+ */
+function dropboxApiArg(arg) {
+    return JSON.stringify(arg).replace(/[\u007f-\uffff]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
 async function downloadFile(input, context) {
     const { accessToken, fetcher, transitFiles } = context;
     if (!transitFiles) {
@@ -218,7 +236,7 @@ async function downloadFile(input, context) {
         method: "POST",
         headers: {
             ...dropboxAuthHeaders(accessToken),
-            "Dropbox-API-Arg": JSON.stringify({
+            "Dropbox-API-Arg": dropboxApiArg({
                 path: requireString(input.path, "dropbox download path"),
             }),
         },
@@ -251,7 +269,7 @@ async function uploadFile(input, accessToken, fetcher) {
         headers: {
             ...dropboxAuthHeaders(accessToken),
             "Content-Type": source.mimeType || "application/octet-stream",
-            "Dropbox-API-Arg": JSON.stringify(arg),
+            "Dropbox-API-Arg": dropboxApiArg(arg),
         },
         body: Buffer.from(source.bytes),
     });
@@ -491,7 +509,7 @@ async function getSharedLinkFile(input, context) {
         method: "POST",
         headers: {
             ...dropboxAuthHeaders(accessToken),
-            "Dropbox-API-Arg": JSON.stringify(arg),
+            "Dropbox-API-Arg": dropboxApiArg(arg),
         },
         signal: context.signal,
     });

package/src/providers/feishu_app_bot/scopes.js

@@ -15,6 +15,6 @@ export const feishuAppBotScopes = {
     groupAtReadonly: "im:message.group_at_msg:readonly",
     groupAtWithBotReadonly: "im:message.group_at_msg.include_bot:readonly",
     groupReadonly: "im:message.group_msg:readonly",
-    applicationRead: "application:application:readonly",
+    applicationRead: "application:application:self_manage",
     applicationVersionRead: "application:application.app_version:readonly",
 };

package/src/providers/mcp-client.d.ts

@@ -10,6 +10,7 @@ export interface McpClientOptions {
     signal?: AbortSignal;
     protocolVersion?: McpProtocolVersion;
     terminateSession?: boolean;
+    retryOnSessionNotFound?: boolean;
     mapError?: (error: unknown) => unknown;
 }
 export declare function withMcpClient<T>(options: McpClientOptions, run: (client: Client) => Promise<T>): Promise<T>;

package/src/providers/mcp-client.js

@@ -1,4 +1,4 @@
-import { Client } from "@modelcontextprotocol/client";
+import { Client, SdkHttpError } from "@modelcontextprotocol/client";
 import { SSEClientTransport } from "@modelcontextprotocol/client";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/client/validators/cf-worker";
@@ -6,33 +6,47 @@ const mcpConnectTimeoutMs = 60_000;
 const modernMcpProtocolVersion = "2026-07-28";
 const mcpJsonSchemaValidator = new CfWorkerJsonSchemaValidator();
 export async function withMcpClient(options, run) {
-    const transportOptions = {
-        fetch: options.fetcher,
-        requestInit: {
-            headers: options.headers,
-            redirect: options.redirect,
-            signal: options.signal,
-        },
-    };
-    const transport = options.transport === "sse"
-        ? new SSEClientTransport(options.endpoint, transportOptions)
-        : new StreamableHTTPClientTransport(options.endpoint, transportOptions);
-    const client = new Client({ name: "open-connector", version: "1.0.0" }, {
-        jsonSchemaValidator: mcpJsonSchemaValidator,
-        versionNegotiation: { mode: resolveVersionNegotiationMode(options.protocolVersion) },
-    });
-    try {
-        await client.connect(transport, { timeout: mcpConnectTimeoutMs, signal: options.signal });
-        return await run(client);
-    }
-    catch (error) {
-        throw options.mapError ? options.mapError(error) : error;
-    }
-    finally {
-        if (options.terminateSession && transport instanceof StreamableHTTPClientTransport) {
-            await terminateMcpSession(transport);
+    let retriedSession = false;
+    while (true) {
+        const transportOptions = {
+            fetch: options.fetcher,
+            requestInit: {
+                headers: options.headers,
+                redirect: options.redirect,
+                signal: options.signal,
+            },
+        };
+        const transport = options.transport === "sse"
+            ? new SSEClientTransport(options.endpoint, transportOptions)
+            : new StreamableHTTPClientTransport(options.endpoint, transportOptions);
+        const client = new Client({ name: "open-connector", version: "1.0.0" }, {
+            jsonSchemaValidator: mcpJsonSchemaValidator,
+            versionNegotiation: { mode: resolveVersionNegotiationMode(options.protocolVersion) },
+        });
+        let connected = false;
+        try {
+            await client.connect(transport, { timeout: mcpConnectTimeoutMs, signal: options.signal });
+            connected = true;
+            return await run(client);
+        }
+        catch (error) {
+            if (connected &&
+                options.transport === "streamable_http" &&
+                options.retryOnSessionNotFound === true &&
+                !retriedSession &&
+                error instanceof SdkHttpError &&
+                error.status === 404) {
+                retriedSession = true;
+                continue;
+            }
+            throw options.mapError ? options.mapError(error) : error;
+        }
+        finally {
+            if (options.terminateSession && transport instanceof StreamableHTTPClientTransport) {
+                await terminateMcpSession(transport);
+            }
+            await client.close().catch(() => undefined);
         }
-        await client.close().catch(() => undefined);
     }
 }
 async function terminateMcpSession(transport) {

package/src/providers/sellersprite_mcp/executors.js

@@ -87,8 +87,9 @@ function normalize(result) {
         const message = envelope.message ?? `SellerSprite MCP tool failed with ${envelope.code}`;
         if (["ERROR_UNAUTHORIZED", "ERROR_SECRET_KEY", "ERROR_SECRET_KEY_INVALID", "ERROR_SECRET_KEY_OVERDUE"].includes(envelope.code))
             throw new ProviderRequestError(401, message, envelope);
-        if (envelope.code === "ERROR_VISIT_MAX")
+        if (envelope.code === "ERROR_VISIT_MAX" || envelope.code === "ERROR_MAXIMUM_ACCESS_PER_MINUTE") {
             throw new ProviderRequestError(429, message, envelope);
+        }
         if (envelope.code === "ERROR_AUTH_ERROR")
             throw new ProviderRequestError(403, message, envelope);
         if (envelope.code === "ERROR_PARAM")

package/src/providers/slack/runtime.js

@@ -688,10 +688,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/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/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,
     };