@oomol-lab/open-connector 1.6.1 → 1.6.2

package/src/providers/mailsoftly/actions.js

@@ -122,12 +122,14 @@ const searchResultSchema = s.looseRequiredObject("Mailsoftly contact search resu
 export const mailsoftlyActions = [
     defineProviderAction(service, {
         name: "get_contacts",
+        operationType: "read",
         description: "List all contacts in the authenticated Mailsoftly account.",
         inputSchema: emptyInputSchema,
         outputSchema: s.array("Contacts in the Mailsoftly account.", contactSummarySchema),
     }),
     defineProviderAction(service, {
         name: "get_contact",
+        operationType: "read",
         description: "Retrieve one Mailsoftly contact by ID, optionally with detailed fields.",
         inputSchema: s.object("Parameters for retrieving a Mailsoftly contact.", {
             contact_id: contactIdSchema,
@@ -137,18 +139,21 @@ export const mailsoftlyActions = [
     }),
     defineProviderAction(service, {
         name: "create_contact",
+        operationType: "write",
         description: "Create a Mailsoftly contact with a unique email address.",
         inputSchema: createContactInputSchema,
         outputSchema: contactSchema,
     }),
     defineProviderAction(service, {
         name: "update_contact",
+        operationType: "write",
         description: "Update selected fields on an existing Mailsoftly contact.",
         inputSchema: updateContactInputSchema,
         outputSchema: contactSchema,
     }),
     defineProviderAction(service, {
         name: "search_contacts",
+        operationType: "read",
         description: "Search Mailsoftly contacts by exact email, first name, or last name.",
         inputSchema: s.object("Exact-match criteria for searching Mailsoftly contacts.", {
             email: s.string("The exact email value to match."),
@@ -159,12 +164,14 @@ export const mailsoftlyActions = [
     }),
     defineProviderAction(service, {
         name: "get_contact_lists",
+        operationType: "read",
         description: "List general Mailsoftly contact lists and their contact counts.",
         inputSchema: emptyInputSchema,
         outputSchema: s.array("General contact lists in the Mailsoftly account.", contactListSchema),
     }),
     defineProviderAction(service, {
         name: "get_contact_list",
+        operationType: "read",
         description: "Retrieve one Mailsoftly contact list by ID.",
         inputSchema: s.requiredObject("Parameters for retrieving a Mailsoftly contact list.", {
             contact_list_id: contactListIdSchema,
@@ -179,6 +186,7 @@ export const mailsoftlyActions = [
     }),
     defineProviderAction(service, {
         name: "get_contact_list_contacts",
+        operationType: "read",
         description: "List contacts belonging to a Mailsoftly contact list.",
         inputSchema: s.requiredObject("Parameters for listing contacts in a Mailsoftly contact list.", {
             contact_list_id: contactListIdSchema,
@@ -187,6 +195,7 @@ export const mailsoftlyActions = [
     }),
     defineProviderAction(service, {
         name: "create_contact_list",
+        operationType: "write",
         description: "Create an empty Mailsoftly contact list.",
         inputSchema: s.requiredObject("Fields for creating a Mailsoftly contact list.", {
             name: s.nonEmptyString("The contact list name."),
@@ -200,6 +209,7 @@ export const mailsoftlyActions = [
     }),
     defineProviderAction(service, {
         name: "add_contact_to_contact_list",
+        operationType: "write",
         description: "Add an existing Mailsoftly contact to a contact list.",
         inputSchema: s.requiredObject("IDs for adding a contact to a Mailsoftly list.", {
             contact_list_id: contactListIdSchema,
@@ -212,6 +222,7 @@ export const mailsoftlyActions = [
     }),
     defineProviderAction(service, {
         name: "add_contacts_to_contact_list",
+        operationType: "write",
         description: "Add contacts to a Mailsoftly list by email, creating contacts that do not already exist.",
         inputSchema: s.requiredObject("Contacts to add to a Mailsoftly contact list.", {
             contact_list_id: contactListIdSchema,

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

@@ -9,6 +9,7 @@ export interface McpClientOptions {
     redirect?: RequestRedirect;
     signal?: AbortSignal;
     protocolVersion?: McpProtocolVersion;
+    terminateSession?: 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

@@ -29,9 +29,30 @@ export async function withMcpClient(options, run) {
         throw options.mapError ? options.mapError(error) : error;
     }
     finally {
+        if (options.terminateSession && transport instanceof StreamableHTTPClientTransport) {
+            await terminateMcpSession(transport);
+        }
         await client.close().catch(() => undefined);
     }
 }
+async function terminateMcpSession(transport) {
+    let timer;
+    const termination = Promise.resolve()
+        .then(() => transport.terminateSession())
+        .catch(() => undefined);
+    try {
+        await Promise.race([
+            termination,
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, 2_000);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
 function resolveVersionNegotiationMode(protocolVersion) {
     return protocolVersion === "modern" ? { pin: modernMcpProtocolVersion } : "legacy";
 }

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

@@ -0,0 +1,37 @@
+import type { ProviderFetch } from "./provider-runtime.ts";
+import type { ToolAnnotations } from "@modelcontextprotocol/client";
+import { Client } from "@modelcontextprotocol/client";
+export type McpClientToolResult = Awaited<ReturnType<Client["callTool"]>>;
+export interface McpToolSummary {
+    name: string;
+    description?: string;
+    annotations?: ToolAnnotations;
+    inputSchema: Record<string, unknown>;
+}
+export interface McpToolOptions {
+    endpoint: string;
+    service: string;
+    fetcher?: ProviderFetch;
+    headers?: Record<string, string>;
+    redirect?: RequestRedirect;
+    terminateSession?: boolean;
+    requestTimeoutMs?: number;
+    maxResponseBytes?: number;
+    signal?: AbortSignal;
+    toolListMaxBytes?: number;
+    toolListMaxPages?: number;
+    toolListMaxTools?: number;
+    toolListTimeoutMs?: number;
+}
+interface ListMcpToolsOptions {
+    includeAnnotations?: boolean;
+}
+export declare function listMcpTools(input: McpToolOptions, options?: ListMcpToolsOptions): Promise<McpToolSummary[]>;
+interface CallMcpToolOptions extends McpToolOptions {
+    toolName: string;
+    arguments: Record<string, unknown>;
+    authorizeTool?: (tool: McpToolSummary | undefined) => void | Promise<void>;
+    transformToolResult?: (result: McpClientToolResult) => McpClientToolResult;
+}
+export declare function callMcpTool(input: CallMcpToolOptions): Promise<unknown>;
+export {};

package/src/providers/mcp-tools.js

@@ -0,0 +1,207 @@
+import { Client, ProtocolError, ProtocolErrorCode, SdkError, SdkErrorCode, SdkHttpError, SseError, UnauthorizedError, } from "@modelcontextprotocol/client";
+import { withMcpClient } from "./mcp-client.js";
+import { createProviderTimeout, isAbortLikeError, providerFetch, providerUserAgent, ProviderRequestError, } from "./provider-runtime.js";
+const defaultMcpToolListMaxBytes = 16 * 1024 * 1024;
+const defaultMcpToolListMaxPages = 100;
+const defaultMcpToolListMaxTools = 10_000;
+const defaultMcpToolListTimeoutMs = 60_000;
+async function withToolClient(input, run) {
+    const fetcher = input.fetcher ?? providerFetch;
+    const limitedFetcher = createLimitedMcpFetch(fetcher, input.service, input.maxResponseBytes);
+    return withMcpClient({
+        endpoint: new URL(input.endpoint),
+        transport: "streamable_http",
+        signal: input.signal,
+        headers: { "user-agent": providerUserAgent, ...input.headers },
+        redirect: input.redirect,
+        fetcher: limitedFetcher,
+        mapError: (error) => mapMcpError(input.service, error),
+        terminateSession: input.terminateSession,
+    }, run);
+}
+function createLimitedMcpFetch(fetcher, service, maxResponseBytes) {
+    if (maxResponseBytes === undefined)
+        return fetcher;
+    return async (url, init) => limitMcpResponse(await fetcher(url, init), service, maxResponseBytes);
+}
+export async function listMcpTools(input, options = {}) {
+    return withToolClient(input, async (client) => {
+        const tools = await listAllStreamableHttpMcpTools(client, input);
+        return tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            annotations: options.includeAnnotations ? tool.annotations : undefined,
+            inputSchema: tool.inputSchema,
+        }));
+    });
+}
+export async function callMcpTool(input) {
+    return withToolClient(input, async (client) => {
+        if (input.authorizeTool) {
+            const tools = await listAllStreamableHttpMcpTools(client, input);
+            const matchingTools = tools.filter((tool) => tool.name === input.toolName);
+            if (matchingTools.length > 1) {
+                throw new ProviderRequestError(502, `${input.service} MCP tools/list returned multiple definitions for the requested tool`, undefined, "provider_error");
+            }
+            await input.authorizeTool(matchingTools[0]);
+        }
+        const requestTimeout = createProviderTimeout(input.signal, input.requestTimeoutMs);
+        let result;
+        try {
+            result = await client.callTool({
+                name: input.toolName,
+                arguments: input.arguments,
+            }, { signal: requestTimeout.signal });
+        }
+        finally {
+            requestTimeout.cleanup();
+        }
+        const transformedResult = input.transformToolResult ? input.transformToolResult(result) : result;
+        return normalizeMcpToolResult(input.service, input.toolName, transformedResult);
+    });
+}
+async function limitMcpResponse(response, service, maxBytes) {
+    const contentLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+        await response.body?.cancel().catch(() => undefined);
+        throw createMcpResponseTooLargeError(service, maxBytes);
+    }
+    if (!response.body) {
+        return response;
+    }
+    let receivedBytes = 0;
+    const body = response.body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            receivedBytes += chunk.byteLength;
+            if (receivedBytes > maxBytes) {
+                throw createMcpResponseTooLargeError(service, maxBytes);
+            }
+            controller.enqueue(chunk);
+        },
+    }));
+    const limitedResponse = new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+    Object.defineProperties(limitedResponse, {
+        url: { value: response.url },
+        redirected: { value: response.redirected },
+        type: { value: response.type },
+    });
+    return limitedResponse;
+}
+function createMcpResponseTooLargeError(service, maxBytes) {
+    return new ProviderRequestError(502, `${service} MCP response exceeds ${maxBytes} bytes`, undefined, "provider_error");
+}
+async function listAllStreamableHttpMcpTools(client, input) {
+    const tools = [];
+    const seenCursors = new Set();
+    const maxBytes = input.toolListMaxBytes ?? defaultMcpToolListMaxBytes;
+    const maxPages = input.toolListMaxPages ?? defaultMcpToolListMaxPages;
+    const maxTools = input.toolListMaxTools ?? defaultMcpToolListMaxTools;
+    const deadline = Date.now() + (input.toolListTimeoutMs ?? defaultMcpToolListTimeoutMs);
+    let totalBytes = 0;
+    let pageCount = 0;
+    let cursor;
+    do {
+        if (pageCount >= maxPages) {
+            throw new ProviderRequestError(502, `${input.service} MCP tools/list exceeded ${maxPages} pages`, undefined, "provider_error");
+        }
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+            throw new ProviderRequestError(504, `${input.service} MCP tools/list timed out`, undefined, "provider_error");
+        }
+        const requestTimeout = createProviderTimeout(input.signal, input.requestTimeoutMs);
+        let result;
+        try {
+            result = await client.request({ method: "tools/list", params: cursor === undefined ? {} : { cursor } }, { timeout: remainingMs, signal: requestTimeout.signal });
+        }
+        finally {
+            requestTimeout.cleanup();
+        }
+        pageCount += 1;
+        totalBytes += new TextEncoder().encode(JSON.stringify(result.tools)).byteLength;
+        if (totalBytes > maxBytes) {
+            throw new ProviderRequestError(502, `${input.service} MCP tools/list exceeded ${maxBytes} bytes`, undefined, "provider_error");
+        }
+        if (tools.length + result.tools.length > maxTools) {
+            throw new ProviderRequestError(502, `${input.service} MCP tools/list exceeded ${maxTools} tools`, undefined, "provider_error");
+        }
+        tools.push(...result.tools);
+        cursor = result.nextCursor;
+        if (cursor !== undefined && seenCursors.has(cursor)) {
+            throw new ProviderRequestError(502, `${input.service} MCP tools/list returned a repeated cursor`, undefined, "provider_error");
+        }
+        if (cursor !== undefined) {
+            seenCursors.add(cursor);
+        }
+    } while (cursor !== undefined);
+    return tools;
+}
+function normalizeMcpToolResult(service, toolName, result) {
+    if ("content" in result && result.isError) {
+        const message = formatMcpToolContent(result);
+        if (message.startsWith("MCP error -32601:") || message.startsWith("MCP error -32602:")) {
+            throw new ProviderRequestError(400, `${service} MCP tool ${toolName} rejected the input: ${message}`, undefined, "invalid_input");
+        }
+        throw new ProviderRequestError(502, `${service} MCP tool ${toolName} returned an error: ${message}`, undefined, "provider_error");
+    }
+    if ("toolResult" in result) {
+        return result;
+    }
+    return result.structuredContent !== undefined ? result.structuredContent : result;
+}
+function formatMcpToolContent(result) {
+    const content = "content" in result && Array.isArray(result.content) ? result.content : [];
+    const text = content
+        .map((content) => {
+        if (content.type === "text") {
+            return content.text;
+        }
+        if (content.type === "resource") {
+            return "text" in content.resource ? content.resource.text : content.resource.uri;
+        }
+        if (content.type === "resource_link") {
+            return content.uri;
+        }
+        return content.type;
+    })
+        .filter(Boolean)
+        .join("; ");
+    return text.slice(0, 300) || "empty error content";
+}
+function mapMcpError(service, error) {
+    if (error instanceof ProviderRequestError) {
+        return error;
+    }
+    if (isAbortLikeError(error)) {
+        return new ProviderRequestError(504, `${service} MCP request timed out`, undefined, "provider_error");
+    }
+    if (error instanceof SdkError && typeof error.data === "object" && error.data !== null) {
+        const cause = "cause" in error.data ? error.data.cause : undefined;
+        if (cause instanceof ProviderRequestError) {
+            return cause;
+        }
+    }
+    if (error instanceof UnauthorizedError) {
+        return new ProviderRequestError(401, `${service} MCP token is invalid or expired`, undefined, "provider_error");
+    }
+    if (error instanceof SdkHttpError || error instanceof SseError) {
+        const status = error instanceof SdkHttpError ? error.status : error.code;
+        if (status === 429) {
+            return new ProviderRequestError(429, `${service} MCP request failed: ${error.message}`, undefined, "rate_limited");
+        }
+        return new ProviderRequestError(status === 401 || status === 403 ? status : status && status >= 400 && status < 500 ? 400 : 502, `${service} MCP request failed: ${error.message}`, undefined, "provider_error");
+    }
+    if (error instanceof SdkError && error.code === SdkErrorCode.RequestTimeout) {
+        return new ProviderRequestError(504, `${service} MCP request timed out`, undefined, "provider_error");
+    }
+    if (error instanceof ProtocolError) {
+        if (error.code === ProtocolErrorCode.MethodNotFound || error.code === ProtocolErrorCode.InvalidParams) {
+            return new ProviderRequestError(400, `${service} MCP request rejected the input: ${error.message}`, undefined, "invalid_input");
+        }
+        return new ProviderRequestError(502, `${service} MCP request failed: ${error.message}`, undefined, "provider_error");
+    }
+    return new ProviderRequestError(502, `${service} MCP request failed`, undefined, "provider_error");
+}

package/src/providers/mendeley/actions.js

@@ -34,6 +34,7 @@ const paginationProperties = {
 export const mendeleyActions = [
     defineProviderAction(service, {
         name: "list_documents",
+        operationType: "read",
         description: "List document metadata from the authorized user's Mendeley library.",
         requiredScopes: [readScope],
         inputSchema: s.object("Input parameters for listing Mendeley documents.", {
@@ -61,6 +62,7 @@ export const mendeleyActions = [
     }),
     defineProviderAction(service, {
         name: "get_document",
+        operationType: "read",
         description: "Get document metadata from the authorized user's Mendeley library by ID.",
         requiredScopes: [readScope],
         inputSchema: s.object("Input parameters for getting a Mendeley document.", {
@@ -73,6 +75,7 @@ export const mendeleyActions = [
     }),
     defineProviderAction(service, {
         name: "create_document",
+        operationType: "write",
         description: "Create a document in the authorized user's Mendeley library from JSON metadata.",
         requiredScopes: [writeScope],
         inputSchema: s.object("Metadata for creating a Mendeley document.", documentMetadataProperties, {
@@ -84,6 +87,7 @@ export const mendeleyActions = [
     }),
     defineProviderAction(service, {
         name: "update_document",
+        operationType: "write",
         description: "Update selected metadata fields on a Mendeley library document.",
         requiredScopes: [writeScope],
         inputSchema: s.object("Metadata fields to update on a Mendeley document.", {
@@ -98,6 +102,7 @@ export const mendeleyActions = [
     }),
     defineProviderAction(service, {
         name: "delete_document",
+        operationType: "destructive",
         description: "Permanently delete a document from the authorized user's Mendeley library.",
         requiredScopes: [writeScope],
         inputSchema: s.object("Input parameters for deleting a Mendeley document.", {
@@ -110,6 +115,7 @@ export const mendeleyActions = [
     }),
     defineProviderAction(service, {
         name: "search_catalog",
+        operationType: "read",
         description: "Search Mendeley's public catalog for document metadata.",
         requiredScopes: [readScope],
         inputSchema: s.object("Input parameters for searching the Mendeley catalog.", {
@@ -127,6 +133,7 @@ export const mendeleyActions = [
     }),
     defineProviderAction(service, {
         name: "get_catalog_document",
+        operationType: "read",
         description: "Get a public Mendeley catalog document by its Mendeley ID.",
         requiredScopes: [readScope],
         inputSchema: s.object("Input parameters for getting a catalog document.", {

package/src/providers/microsoft_teams/executors.js

@@ -75,8 +75,8 @@ async function getCurrentUser(context) {
         $select: "id,displayName,mail,userPrincipalName",
     }));
 }
-async function listJoinedTeams(_input, context) {
-    const payload = await microsoftGraphJson("me/joinedTeams", requestOptions(context, "list joined teams"));
+async function listJoinedTeams(input, context) {
+    const payload = await microsoftGraphJson(optionalString(input.nextLink) ?? "me/joinedTeams", requestOptions(context, "list joined teams", undefined, (pathname) => pathname === "/v1.0/me/joinedTeams"));
     return listOutput(payload, "teams");
 }
 async function getTeam(input, context) {

package/src/providers/missive/actions.js

@@ -131,6 +131,7 @@ const listConversationsInputSchema = s.object("Input payload for listing Missive
 export const missiveActions = [
     defineProviderAction(service, {
         name: "list_users",
+        operationType: "read",
         description: "List users visible to the authenticated Missive API token.",
         requiredScopes: [],
         inputSchema: noInputSchema,
@@ -140,6 +141,7 @@ export const missiveActions = [
     }),
     defineProviderAction(service, {
         name: "list_organizations",
+        operationType: "read",
         description: "List organizations the authenticated Missive API token owner belongs to.",
         requiredScopes: [],
         inputSchema: pagination200InputSchema,
@@ -149,6 +151,7 @@ export const missiveActions = [
     }),
     defineProviderAction(service, {
         name: "list_teams",
+        operationType: "read",
         description: "List teams visible to the authenticated Missive API token.",
         requiredScopes: [],
         inputSchema: noInputSchema,
@@ -158,6 +161,7 @@ export const missiveActions = [
     }),
     defineProviderAction(service, {
         name: "list_contact_books",
+        operationType: "read",
         description: "List Missive contact books the authenticated user can access.",
         requiredScopes: [],
         inputSchema: pagination200InputSchema,
@@ -167,6 +171,7 @@ export const missiveActions = [
     }),
     defineProviderAction(service, {
         name: "list_contacts",
+        operationType: "read",
         description: "List contacts from one Missive contact book with documented filters.",
         requiredScopes: [],
         inputSchema: listContactsInputSchema,
@@ -176,6 +181,7 @@ export const missiveActions = [
     }),
     defineProviderAction(service, {
         name: "get_contact",
+        operationType: "read",
         description: "Get one Missive contact by ID.",
         requiredScopes: [],
         inputSchema: idInputSchema("contact"),
@@ -185,6 +191,7 @@ export const missiveActions = [
     }),
     defineProviderAction(service, {
         name: "list_conversations",
+        operationType: "read",
         description: "List Missive conversations using a required mailbox, team, or shared-label filter.",
         requiredScopes: [],
         inputSchema: listConversationsInputSchema,
@@ -194,6 +201,7 @@ export const missiveActions = [
     }),
     defineProviderAction(service, {
         name: "get_conversation",
+        operationType: "read",
         description: "Get one Missive conversation by ID.",
         requiredScopes: [],
         inputSchema: idInputSchema("conversation"),

package/src/providers/more_trees/actions.js

@@ -71,12 +71,14 @@ const plantTreesOutputSchema = s.looseRequiredObject("The More Trees planting re
 export const moreTreesActions = [
     defineProviderAction(service, {
         name: "get_account",
+        operationType: "read",
         description: "Get account identity, planting credit balance, and forest identifiers for the connected More Trees account.",
         inputSchema: s.requiredObject("The request for the connected More Trees account.", {}),
         outputSchema: accountOutputSchema,
     }),
     defineProviderAction(service, {
         name: "get_forest",
+        operationType: "read",
         description: "Get More Trees forest branding and cumulative planting and carbon statistics.",
         inputSchema: s.object("The request for a More Trees forest.", {
             forestSlugOrAccountCode: s.nonEmptyString("The forest slug or account code to inspect. Defaults to the connected account code."),
@@ -85,12 +87,14 @@ export const moreTreesActions = [
     }),
     defineProviderAction(service, {
         name: "list_projects",
+        operationType: "read",
         description: "List active More Trees planting projects and the tree species available within each project.",
         inputSchema: s.requiredObject("The request for active More Trees planting projects.", {}),
         outputSchema: s.array("The active planting projects returned by More Trees.", projectSchema),
     }),
     defineProviderAction(service, {
         name: "plant_trees",
+        operationType: "write",
         description: "Plant trees for the connected More Trees account or gift trees to recipients, with optional non-persistent test mode.",
         inputSchema: plantTreesInputSchema,
         outputSchema: plantTreesOutputSchema,

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

@@ -1,4 +1,3 @@
 import type { ActionDefinition } from "../../core/types.ts";
-export type NetlifyActionName = "get_current_user" | "list_accounts" | "get_account" | "list_sites" | "get_site" | "list_site_deploys" | "get_deploy" | "cancel_deploy" | "lock_deploy" | "unlock_deploy" | "create_site_build" | "create_site_deploy_from_zip_url" | "upload_deploy_file_from_url" | "upload_deploy_function_from_zip_url" | "get_build" | "notify_build_start" | "list_site_forms" | "list_submissions" | "delete_submission";
 export declare const netlifyActions: ActionDefinition[];
 export declare const netlifyConnectorScopes: readonly string[];