@oomol-lab/open-connector 1.9.0 → 1.9.2

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

@@ -8,6 +8,7 @@ export interface McpToolSummary {
     annotations?: ToolAnnotations;
     inputSchema: Record<string, unknown>;
     outputSchema?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
 }
 export interface McpToolOptions {
     endpoint: string;
@@ -24,7 +25,9 @@ export interface McpToolOptions {
     toolListMaxTools?: number;
     toolListTimeoutMs?: number;
 }
+export declare function withMcpToolClient<T>(input: McpToolOptions, run: (client: Client) => Promise<T>): Promise<T>;
 interface ListMcpToolsOptions {
+    includeMetadata?: boolean;
     includeOutputSchema?: boolean;
     includeAnnotations?: boolean;
 }

package/src/providers/mcp-tools.js

@@ -5,7 +5,7 @@ const defaultMcpToolListMaxBytes = 16 * 1024 * 1024;
 const defaultMcpToolListMaxPages = 100;
 const defaultMcpToolListMaxTools = 10_000;
 const defaultMcpToolListTimeoutMs = 60_000;
-async function withToolClient(input, run) {
+export async function withMcpToolClient(input, run) {
     const fetcher = input.fetcher ?? providerFetch;
     const limitedFetcher = createLimitedMcpFetch(fetcher, input.service, input.maxResponseBytes);
     return withMcpClient({
@@ -25,9 +25,10 @@ function createLimitedMcpFetch(fetcher, service, maxResponseBytes) {
     return async (url, init) => limitMcpResponse(await fetcher(url, init), service, maxResponseBytes);
 }
 export async function listMcpTools(input, options = {}) {
-    return withToolClient(input, async (client) => {
+    return withMcpToolClient(input, async (client) => {
         const tools = await listAllStreamableHttpMcpTools(client, input);
         return tools.map((tool) => ({
+            metadata: options.includeMetadata ? tool._meta : undefined,
             name: tool.name,
             description: tool.description,
             annotations: options.includeAnnotations ? tool.annotations : undefined,
@@ -37,7 +38,7 @@ export async function listMcpTools(input, options = {}) {
     });
 }
 export async function callMcpTool(input) {
-    return withToolClient(input, async (client) => {
+    return withMcpToolClient(input, async (client) => {
         if (input.authorizeTool) {
             const tools = await listAllStreamableHttpMcpTools(client, input);
             const matchingTools = tools.filter((tool) => tool.name === input.toolName);
@@ -52,7 +53,7 @@ export async function callMcpTool(input) {
             result = await client.callTool({
                 name: input.toolName,
                 arguments: input.arguments,
-            }, { signal: requestTimeout.signal });
+            }, { signal: requestTimeout.signal, timeout: input.requestTimeoutMs });
         }
         finally {
             requestTimeout.cleanup();

package/src/providers/minimax/executors.js

@@ -1,12 +1,14 @@
 import { createHash } from "node:crypto";
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { defineProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, requireApiKeyCredential, requiredInputString, } from "../provider-runtime.js";
+import { defineProviderExecutors, defineProviderProxy, providerInputError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, requiredInputString, } from "../provider-runtime.js";
+import { minimaxTextModels, selectMinimaxModels } from "./text-models.js";
 const service = "minimax";
 const minimaxApiBaseUrl = "https://api.minimax.io";
 const minimaxChinaApiBaseUrl = "https://api.minimaxi.com";
 export const minimaxActionHandlers = {
-    list_models(_input, context) {
-        return minimaxGetJson("/v1/models", context);
+    async list_models(input, context) {
+        const payload = await minimaxGetJson("/v1/models", context);
+        return input.include_legacy === true ? payload : selectMinimaxModels(payload);
     },
     retrieve_model(input, context) {
         const modelId = requiredInputString(input.modelId, "modelId");
@@ -156,9 +158,22 @@ function minimaxHeaders(apiKey, headers) {
     };
 }
 function normalizeMinimaxBody(input) {
+    const model = input.model === undefined ? minimaxTextModels[0] : requiredInputString(input.model, "model");
+    if (model === minimaxTextModels[0]) {
+        const effort = optionalRecord(input.reasoning)?.effort;
+        if (effort !== undefined && !["low", "medium", "high", "xhigh", "max"].includes(String(effort))) {
+            throw providerInputError("MiniMax-M3.1-Flash reasoning.effort must be low, medium, high, xhigh, or max");
+        }
+        if (input.service_tier !== undefined) {
+            throw providerInputError("MiniMax-M3.1-Flash does not support service_tier");
+        }
+    }
     return compactObject({
         ...input,
-        model: trimString(input.model),
+        model,
+        reasoning: model === minimaxTextModels[0]
+            ? { ...optionalRecord(input.reasoning), effort: optionalRecord(input.reasoning)?.effort ?? "max" }
+            : input.reasoning,
         input: typeof input.input === "string" ? input.input.trim() : input.input,
         instructions: trimString(input.instructions),
         prompt_cache_key: trimString(input.prompt_cache_key),

package/src/providers/minimax/text-models.d.ts

@@ -0,0 +1,2 @@
+export declare const minimaxTextModels: string[];
+export declare function selectMinimaxModels(payload: unknown, gateway?: boolean): unknown;

package/src/providers/minimax/text-models.js

@@ -0,0 +1,34 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+export const minimaxTextModels = ["MiniMax-M3.1-Flash", "MiniMax-M3"];
+export function selectMinimaxModels(payload, gateway = false) {
+    const record = optionalRecord(payload);
+    if (!Array.isArray(record?.data))
+        return payload;
+    const preferred = gateway ? ["minimax/minimax-m3.1-flash:free", "minimax/minimax-m3"] : minimaxTextModels;
+    const current = [];
+    const remaining = [];
+    let insertionIndex;
+    for (const item of record.data) {
+        const id = optionalString(optionalRecord(item)?.id) ?? "";
+        if (preferred.includes(id)) {
+            insertionIndex ??= remaining.length;
+            current.push(item);
+            continue;
+        }
+        const name = (gateway && id.startsWith("minimax/") ? id.slice(8) : gateway ? "" : id)
+            .toLowerCase()
+            .split(":", 1)[0];
+        const oldGeneration = ["minimax-m1", "minimax-m2"].some((prefix) => name === prefix || name.startsWith(`${prefix}.`) || name.startsWith(`${prefix}-`));
+        const legacy = oldGeneration ||
+            name.startsWith("minimax-text-") ||
+            name === "minimax-01" ||
+            name === "m2-her" ||
+            (name.startsWith("abab") && "0123456789".includes(name[4] ?? " "));
+        if (!legacy)
+            remaining.push(item);
+    }
+    current.sort((a, b) => preferred.indexOf(optionalString(optionalRecord(a)?.id) ?? "") -
+        preferred.indexOf(optionalString(optionalRecord(b)?.id) ?? ""));
+    remaining.splice(gateway ? (insertionIndex ?? remaining.length) : 0, 0, ...current);
+    return { ...record, data: remaining };
+}

package/src/providers/moneyforward_mcp/manifest.d.ts

@@ -22,8 +22,6 @@ export declare const moneyforwardTools: readonly MoneyforwardToolEntry[];
  * so a wording change on the server also blocks writes until reviewed.
  */
 export declare function schemaDigest(schema: unknown): string;
-/** RFC 8785 JSON Canonicalization for the JSON values a tool schema can hold. */
-export declare function canonicalJson(value: unknown): string;
 /**
  * Normalize an office name for the write guard: NFKC, drop all whitespace, and expand the explicit
  * legal-form abbreviations. No fuzzy matching: a name that differs otherwise is refused.

package/src/providers/moneyforward_mcp/manifest.js

@@ -168,7 +168,7 @@ export function schemaDigest(schema) {
     return sha256Hex(canonicalJson(schema));
 }
 /** RFC 8785 JSON Canonicalization for the JSON values a tool schema can hold. */
-export function canonicalJson(value) {
+function canonicalJson(value) {
     if (Array.isArray(value))
         return `[${value.map(canonicalJson).join(",")}]`;
     if (value !== null && typeof value === "object") {

package/src/providers/notion/executors.js

@@ -1,5 +1,6 @@
-import { compactObject } from "../../core/cast.js";
-import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, providerInputError, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireBearerCredential, toProviderProxyError, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { compactObject, optionalNumber, optionalString } from "../../core/cast.js";
+import { encodePathSegment } from "../../core/request.js";
+import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, providerInputError, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireBearerCredential, requiredInputString, toProviderProxyError, withRetryAfterSeconds, } from "../provider-runtime.js";
 import { notionDatabasePageEvent } from "./trigger-on-database-page-event.js";
 const service = "notion";
 const notionApiBaseUrl = "https://api.notion.com/v1";
@@ -87,6 +88,38 @@ export const notionActionHandlers = {
     list_comments(input, context) {
         return notionListComments(input, context.accessToken, context.fetcher);
     },
+    list_views(input, context) {
+        const databaseId = optionalString(input.databaseId);
+        const dataSourceId = optionalString(input.dataSourceId);
+        if (!databaseId && !dataSourceId) {
+            throw providerInputError("databaseId or dataSourceId is required");
+        }
+        return notionRequest(context.accessToken, {
+            path: "/views",
+            query: {
+                database_id: databaseId,
+                data_source_id: dataSourceId,
+                page_size: optionalNumber(input.pageSize),
+                start_cursor: optionalString(input.startCursor),
+            },
+        }, context.fetcher);
+    },
+    retrieve_view(input, context) {
+        return notionRequest(context.accessToken, { path: `/views/${encodePathSegment(requiredInputString(input.viewId, "viewId"))}` }, context.fetcher);
+    },
+    update_view(input, context) {
+        return notionRequest(context.accessToken, {
+            method: "PATCH",
+            path: `/views/${encodePathSegment(requiredInputString(input.viewId, "viewId"))}`,
+            body: {
+                name: input.name,
+                filter: input.filter,
+                sorts: input.sorts,
+                quick_filters: input.quick_filters,
+                configuration: input.configuration,
+            },
+        }, context.fetcher);
+    },
     create_comment(input, context) {
         return notionCreateComment(input, context.accessToken, context.fetcher);
     },
@@ -586,7 +619,7 @@ async function notionQueryDataSource(input, accessToken, fetcher) {
             sorts: Array.isArray(input.sorts) ? input.sorts : undefined,
             page_size: asNumber(input.pageSize),
             start_cursor: asNonEmptyString(input.startCursor),
-            in_trash: typeof input.in_trash === "boolean" ? input.in_trash : undefined,
+            is_archived: typeof input.is_archived === "boolean" ? input.is_archived : undefined,
             result_type: asNonEmptyString(input.result_type),
         }),
     }, fetcher);

package/src/providers/notion_mcp/executors.js

@@ -1,9 +1,9 @@
 import { ProtocolError, SdkHttpError, UnauthorizedError } from "@modelcontextprotocol/client";
 import { compactObject, looseArray, optionalBoolean, optionalInteger, optionalNumber, optionalRawString, optionalRecord, optionalString, optionalStringArray, requiredRawString, } from "../../core/cast.js";
 import { withMcpClient } from "../mcp-client.js";
-import { defineOAuthProviderExecutors, mapProviderActionSources, providerResponseError, providerUserAgent, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { defineOAuthProviderExecutors, mapProviderActionSources, providerInputError, providerResponseError, providerUserAgent, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
 import { notionMcpEndpoint } from "./endpoints.js";
-import { decodeNotionToolText, parseNotionComments, parseNotionPage, parseNotionSearch, parseNotionSelf, parseNotionToolAccess, } from "./mcp-response.js";
+import { decodeNotionToolText, parseNotionComments, parseNotionCreatedComment, parseNotionCreatedPages, parseNotionPage, parseNotionSearch, parseNotionSelf, parseNotionToolAccess, parseNotionUpdatedPage, } from "./mcp-response.js";
 const service = "notion_mcp";
 const selfUserId = "self";
 const toolsByAction = {
@@ -36,7 +36,45 @@ const toolsByAction = {
         arguments: () => ({}),
         parse: (value) => ({ tools: parseNotionToolAccess(value) }),
     },
+    create_pages: {
+        tool: "notion-create-pages",
+        arguments: (input) => {
+            const pages = looseArray(input.pages);
+            if (pages.length === 0)
+                throw providerInputError("pages is required.");
+            return { ...compactObject(input), pages };
+        },
+        parse: (value) => ({ ...parseNotionCreatedPages(value) }),
+    },
+    update_page: {
+        tool: "notion-update-page",
+        arguments: (input) => ({
+            ...compactObject(input),
+            page_id: requiredInputString(input.page_id, "page_id"),
+            command: requiredInputString(input.command, "command"),
+        }),
+        parse: (value, input) => ({
+            page_id: requiredInputString(input.page_id, "page_id"),
+            ...parseNotionUpdatedPage(value),
+        }),
+    },
+    create_comment: {
+        tool: "notion-create-comment",
+        arguments: (input) => ({
+            ...compactObject(input),
+            page_id: requiredInputString(input.page_id, "page_id"),
+            markdown: requiredInputString(input.markdown, "markdown"),
+        }),
+        parse: (value) => compactObject({ comment: parseNotionCreatedComment(value) }),
+    },
 };
+/**
+ * The actions that change the workspace. Sign-in requires every read tool and
+ * none of these: a workspace whose owner withheld the writes from the
+ * connection, or an older server, may not list them, and a credential must
+ * not be refused for a tool it would never call.
+ */
+const writeActions = new Set(["create_pages", "update_page", "create_comment"]);
 const handlers = mapProviderActionSources(service, toolsByAction, (_actionName, source) => async (input, context) => {
     const result = await callNotionTool(context, source.tool, source.arguments(input));
     return { ...source.parse(result.value, input), raw: result.raw };
@@ -45,14 +83,15 @@ export const executors = defineOAuthProviderExecutors(service, handlers, {
     skipDnsValidation: true,
 });
 export const credentialValidators = {
-    /** Require every tool the actions map, then identify the user so the account key is the Notion user ID. */
+    /** Require the baseline read tools, then identify the user by the Notion user ID. */
     async oauth2(input, { fetcher, signal }) {
         const context = { accessToken: input.accessToken, fetcher, signal };
-        const { toolCount, self } = await withNotionMcpClient(context, "validate", async (client, signal) => {
+        const { toolCount, self } = await withNotionMcpClient(context, async (client, signal) => {
             const tools = await listNotionTools(client, signal);
             const available = new Set(tools.map((tool) => tool.name));
-            const missing = Object.values(toolsByAction)
-                .map((source) => source.tool)
+            const missing = Object.entries(toolsByAction)
+                .filter(([action]) => !writeActions.has(action))
+                .map(([, source]) => source.tool)
                 .filter((tool) => !available.has(tool));
             if (missing.length > 0) {
                 throw new ProviderRequestError(502, `Notion MCP did not expose the tools this connector needs: ${[...new Set(missing)].join(", ")}.`);
@@ -107,7 +146,7 @@ async function listNotionTools(client, signal) {
     return tools;
 }
 async function callNotionTool(context, name, input) {
-    const result = await withNotionMcpClient(context, "execute", (client, signal) => client.callTool({ name, arguments: input }, { signal }));
+    const result = await withNotionMcpClient(context, (client, signal) => client.callTool({ name, arguments: input }, { signal }));
     return readNotionToolResult(name, result);
 }
 /** The text blocks joined are the raw answer; structured content, when the server sends it, is the value. */
@@ -138,7 +177,7 @@ function notionToolError(name, record) {
     }
     return new ProviderRequestError(502, `Notion MCP tool ${name} failed.`, record);
 }
-function withNotionMcpClient(context, phase, run) {
+function withNotionMcpClient(context, run) {
     return runProviderRequest({ signal: context.signal, label: "Notion MCP" }, (signal) => withMcpClient({
         endpoint: new URL(notionMcpEndpoint),
         transport: "streamable_http",
@@ -146,31 +185,21 @@ function withNotionMcpClient(context, phase, run) {
         headers: { authorization: `Bearer ${context.accessToken}`, "user-agent": providerUserAgent },
         redirect: "manual",
         signal,
-        mapError: (error) => mapNotionMcpError(error, phase),
+        mapError: mapNotionMcpError,
     }, (client) => run(client, signal)));
 }
-/**
- * Sign-in reports a rejected token as invalid input (400); a run reports it as an expired authorization (401).
- * Anything unrecognized is left to runProviderRequest, which tells a timeout (504) from a failure (502).
- */
-function mapNotionMcpError(error, phase) {
+// Status alone does not establish that reconnecting can resolve a provider failure.
+function mapNotionMcpError(error) {
     if (error instanceof ProviderRequestError)
         return error;
-    const credentialStatus = phase === "validate" ? 400 : 401;
     if (error instanceof UnauthorizedError) {
-        return new ProviderRequestError(credentialStatus, "Notion MCP credential is invalid or expired.");
+        return new ProviderRequestError(401, "Notion MCP authorization request failed.", undefined, "provider_error");
     }
     if (error instanceof SdkHttpError) {
-        const status = error.status;
-        if (status === 401 || status === 403) {
-            return new ProviderRequestError(credentialStatus, "Notion MCP credential is invalid or expired.");
-        }
-        // The SDK error carries the response body; only the status is reported so a token echoed in it never is.
-        const providerStatus = 400 <= status && status < 500 ? status : 502;
-        return new ProviderRequestError(providerStatus, `Notion MCP request failed with HTTP ${status}.`);
+        return new ProviderRequestError(error.status, `Notion MCP request failed with HTTP ${error.status}.`, undefined, error.status === 429 ? "rate_limited" : "provider_error");
     }
     if (error instanceof ProtocolError) {
-        return new ProviderRequestError(502, `Notion MCP request failed: ${error.message}`);
+        return new ProviderRequestError(502, `Notion MCP protocol error ${error.code}.`, undefined, "provider_error");
     }
     return error;
 }

package/src/providers/notion_mcp/mcp-response.d.ts

@@ -50,6 +50,11 @@ interface NotionMcpToolAccess {
     landing_page_url: string | undefined;
     landing_page_action: string | undefined;
 }
+interface NotionMcpCreatedPage {
+    id?: string;
+    url?: string;
+    title?: string;
+}
 /** Notion's tools answer JSON in a text block on most calls and prose or XML fragments on the rest. */
 export declare function decodeNotionToolText(text: string): unknown;
 /**
@@ -83,4 +88,25 @@ export declare function parseNotionComments(value: unknown): NotionMcpComment[];
  * reason it is unavailable. The reason is kept as text and never interpreted.
  */
 export declare function parseNotionToolAccess(value: unknown): NotionMcpToolAccess[];
+/**
+ * The pages a notion-create-pages answer names, in its order: a `pages`/`results` list of `{id, url, title}`
+ * records, a single page record, or the page links in a prose answer, each id read off its link. An async task's
+ * id travels beside them when the server deferred the work.
+ */
+export declare function parseNotionCreatedPages(value: unknown): {
+    pages: NotionMcpCreatedPage[];
+    async_task_id?: string;
+};
+/** The page a notion-update-page answer names: its link, when the prose or the record carries one, and a deferred task's id. */
+interface NotionMcpUpdatedPage {
+    url?: string;
+    async_task_id?: string;
+    warnings?: Record<string, unknown>[];
+}
+export declare function parseNotionUpdatedPage(value: unknown): NotionMcpUpdatedPage;
+/** The comment a notion-create-comment answer names: the comment record itself, or the first of a listed shape. */
+export declare function parseNotionCreatedComment(value: unknown): {
+    id?: string;
+    discussion_id?: string;
+} | undefined;
 export {};

package/src/providers/notion_mcp/mcp-response.js

@@ -6,6 +6,9 @@ const contentOpening = /<content\b[^<>]*>/i;
 const tagAttribute = /(?<![\w:-])([\w:-]+)\s*=\s*"([^"]*)"/g;
 const anyTag = /<[^<>]+>/g;
 const namedEntities = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+// A Notion page link in prose, and the 32-hex page id a link or an id carries.
+const notionLink = /https:\/\/(?:www\.)?notion\.so\/[^\s)"'<>]+/g;
+const notionPageId = /([0-9a-f]{32})(?:[?#]|$)/i;
 /** Notion's tools answer JSON in a text block on most calls and prose or XML fragments on the rest. */
 export function decodeNotionToolText(text) {
     const trimmed = text.trim();
@@ -143,6 +146,98 @@ export function parseNotionToolAccess(value) {
         ];
     });
 }
+/**
+ * The pages a notion-create-pages answer names, in its order: a `pages`/`results` list of `{id, url, title}`
+ * records, a single page record, or the page links in a prose answer, each id read off its link. An async task's
+ * id travels beside them when the server deferred the work.
+ */
+export function parseNotionCreatedPages(value) {
+    const record = optionalRecord(value);
+    if (record?.object === "async_task") {
+        return { pages: [], ...compactObject({ async_task_id: asyncTaskId(record) }) };
+    }
+    const listed = findList(value, "pages", "results", "created_pages").flatMap((item) => {
+        const page = readCreatedPage(item);
+        return page ? [page] : [];
+    });
+    const single = listed.length === 0 ? readCreatedPage(record) : undefined;
+    const pages = listed.length > 0 ? listed : single ? [single] : linkedPages(optionalString(value) ?? textOf(record));
+    return { pages, ...compactObject({ async_task_id: asyncTaskId(record) }) };
+}
+export function parseNotionUpdatedPage(value) {
+    const record = optionalRecord(value);
+    const url = (record && pickOptionalString(record, "url")) ?? linkedPages(optionalString(value) ?? textOf(record))[0]?.url;
+    return compactObject({
+        url,
+        async_task_id: asyncTaskId(record),
+        warnings: Array.isArray(record?.warnings)
+            ? record.warnings.flatMap((value) => {
+                const warning = optionalRecord(value);
+                return warning ? [warning] : [];
+            })
+            : undefined,
+    });
+}
+/** The comment a notion-create-comment answer names: the comment record itself, or the first of a listed shape. */
+export function parseNotionCreatedComment(value) {
+    const record = optionalRecord(value);
+    const comment = record && (optionalRecord(record.comment) ?? record);
+    const typed = compactObject({
+        id: comment && pickOptionalString(comment, "id", "comment_id"),
+        discussion_id: comment && pickOptionalString(comment, "discussion_id"),
+    });
+    if (Object.keys(typed).length > 0)
+        return typed;
+    const listed = parseNotionComments(value)[0];
+    if (!listed)
+        return undefined;
+    const fromList = compactObject({
+        id: listed.id,
+        discussion_id: listed.discussion_id,
+    });
+    return Object.keys(fromList).length > 0 ? fromList : undefined;
+}
+function readCreatedPage(value) {
+    const record = optionalRecord(value);
+    if (!record)
+        return undefined;
+    const url = pickOptionalString(record, "url");
+    const page = compactObject({
+        id: pickOptionalString(record, "id", "page_id") ?? (url && pageIdOf(url)),
+        url,
+        title: readTitle(record),
+    });
+    return page.id !== undefined || page.url !== undefined ? page : undefined;
+}
+/** The page links a prose answer carries, each with the id its link ends in, in order and without repeats. */
+function linkedPages(text) {
+    if (!text)
+        return [];
+    const seen = new Set();
+    return [...text.matchAll(notionLink)].flatMap((match) => {
+        // A link at the end of a sentence carries its punctuation into the match.
+        const url = match[0].replace(/[.,;:!?]+$/, "");
+        if (seen.has(url))
+            return [];
+        seen.add(url);
+        return [compactObject({ id: pageIdOf(url), url })];
+    });
+}
+function pageIdOf(url) {
+    return notionPageId.exec(url)?.[1]?.toLowerCase();
+}
+/** The text a tool answered under any of its names, for an answer that was JSON with the prose inside it. */
+function textOf(record) {
+    return record ? pickOptionalString(record, "text", "message", "result") : undefined;
+}
+function asyncTaskId(record) {
+    if (!record)
+        return undefined;
+    if (record.object === "async_task")
+        return pickOptionalString(record, "id");
+    const task = optionalRecord(record.async_task) ?? optionalRecord(record.task);
+    return pickOptionalString(record, "async_task_id", "task_id") ?? (task && pickOptionalString(task, "id", "task_id"));
+}
 /** The first present list among keys of a decoded object, or the value itself when it is a list. */
 function findList(value, ...keys) {
     if (Array.isArray(value))

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

@@ -0,0 +1,6 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const octenRoutes: Record<string, {
+    path: string;
+    method: string;
+}>;
+export declare const octenActions: ActionDefinition[];