@mcp-s/connectors 0.0.20260928085734

package/dist/schema/catalog.js

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import { jsonata, method, obj } from "./common.js";
+import { connectorAuthType, connectorCategory } from "./enums.js";
+import { authSettings, wizardStep } from "./auth.js";
+import { endpointSchema, tool } from "./tool.js";
+import { connectorCondition, connectorConfiguration, toolLabel, webhookSettings, } from "./parts.js";
+/**
+ * Version of the catalog format itself. A consumer declares the highest version
+ * it understands; a connector that needs more (via `min_schema`) is skipped by
+ * that consumer, which keeps serving its bundled copy instead.
+ */
+export const CATALOG_SCHEMA_VERSION = 1;
+/**
+ * "api" connectors own their tools: each is an HTTP call against
+ * `api.base_url`. "mcp" connectors proxy a third-party MCP server, so their
+ * tools are discovered from the server rather than authored by hand.
+ */
+export const catalogConnectorKind = z.enum(["api", "mcp"]);
+/** "draft" is catalog-invisible and served only on request. */
+export const catalogConnectorStatus = z.enum([
+    "draft",
+    "soon",
+    "beta",
+    "active",
+    "super-admin",
+    "hidden",
+]);
+export const INTEGRATION_TEMPLATE_FIELDS = [
+    "name",
+    "description",
+    "logo_url",
+    "tools",
+    "auth_settings",
+    "conditions",
+    "webhook_settings",
+    "mcp_proxy",
+    "base_url",
+    "headers",
+    "settings",
+    "proxy_settings",
+    "metadata",
+    "tags",
+];
+export const integrationTemplateField = z.enum(INTEGRATION_TEMPLATE_FIELDS);
+const display = obj({
+    name: z.string(),
+    description: z.string().optional(),
+    /** Icon slug or absolute URL. Falls back to the connector slug. */
+    icon: z.string().optional(),
+    website: z.string().optional(),
+    category: connectorCategory,
+    docs_url: z.string().optional(),
+    /** Published by the vendor itself, e.g. Datadog's own MCP server. */
+    official: z.boolean().optional(),
+    /** Source repository, for open-source MCP servers. */
+    repo: z.string().optional(),
+});
+const api = obj({
+    base_url: z.string(),
+    headers: z.record(z.string(), z.string()).optional(),
+});
+const mcpUrlOption = obj({
+    label: z.string(),
+    url: z.string(),
+    description: z.string().optional(),
+    /** The installing admin types their own URL; `url` is a placeholder. */
+    custom: z.boolean().optional(),
+});
+const mcp = obj({
+    url: z.string(),
+    transport: z.enum(["auto", "streamable-http", "sse"]).optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    /** Selectable endpoints, e.g. regional sites. The first is the default. */
+    url_options: z.array(mcpUrlOption).optional(),
+    /** Label for the endpoint picker. Defaults to "Region". */
+    url_options_label: z.string().optional(),
+});
+const auth = obj({
+    methods: authSettings,
+    default: connectorAuthType.optional(),
+    default_scopes: z.array(z.string()).optional(),
+});
+const verification = z.union([
+    obj({
+        type: z.literal("http"),
+        path: z.string(),
+        method: method.optional(),
+        headers: z.record(z.string(), z.string()).optional(),
+        body: z.record(z.string(), z.unknown()).optional(),
+        success: jsonata.optional(),
+        identity: jsonata.optional(),
+        timeout_ms: z.number().optional(),
+    }),
+    obj({ type: z.literal("mcp"), timeout_ms: z.number().optional() }),
+    obj({ type: z.literal("none") }),
+]);
+const toolsSync = obj({
+    source: z.enum(["manual", "discovered"]),
+    synced_at: z.string(),
+    tool_count: z.number(),
+    endpoint: z.string().optional(),
+});
+const generalSetting = obj({
+    label: z.string(),
+    key: z.string(),
+    description: z.string().optional(),
+    default_value: z.string().optional(),
+});
+const setupStep = obj({
+    title: z.string(),
+    markdown: z.string(),
+    field: integrationTemplateField.optional(),
+});
+const template = obj({
+    request_settings: z.record(z.string(), z.unknown()).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    tags: z.array(z.string()).optional(),
+    locked_fields: z.array(integrationTemplateField).optional(),
+    setup: z.array(setupStep).optional(),
+});
+export const catalogConnectorDefinition = obj({
+    display,
+    api: api.optional(),
+    mcp: mcp.optional(),
+    auth: auth.optional(),
+    verification: verification.optional(),
+    tools: z.array(tool).optional(),
+    tools_sync: toolsSync.optional(),
+    /** Provider request/response schemas per endpoint, for the tool builder. */
+    schemas: z.array(endpointSchema).optional(),
+    webhook: webhookSettings.optional(),
+    conditions: z.array(connectorCondition).optional(),
+    labels: z.array(toolLabel).optional(),
+    general_settings: z.array(generalSetting).optional(),
+    configuration: connectorConfiguration.optional(),
+    template: template.optional(),
+    /** Internal notes. Stripped from everything this package publishes. */
+    notes: z.string().optional(),
+});
+export const catalogConnector = obj({
+    /** Stable catalog identity. Never changes, not even when the slug moves. */
+    id: z.string(),
+    /** Load-bearing at runtime: `integrations.connector_id` resolves through it. */
+    slug: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+    kind: catalogConnectorKind,
+    status: catalogConnectorStatus,
+    /** Products this connector covers, e.g. ["jira", "confluence"]. */
+    applications: z.array(z.string()),
+    /** Catalog entries this connector replaces when it is available. */
+    supersedes: obj({
+        connectors: z.array(z.string()).optional(),
+        registry: z.array(z.string()).optional(),
+    }).optional(),
+    /**
+     * Lowest {@link CATALOG_SCHEMA_VERSION} a consumer must understand to use
+     * this connector. Absent means any version.
+     */
+    min_schema: z.number().int().positive().optional(),
+    definition: catalogConnectorDefinition,
+});
+/** One row of `index.json`: enough to list and search without the definition. */
+export const catalogIndexEntry = obj({
+    id: z.string(),
+    slug: z.string(),
+    kind: catalogConnectorKind,
+    status: catalogConnectorStatus,
+    name: z.string(),
+    description: z.string().optional(),
+    icon: z.string().optional(),
+    category: connectorCategory,
+    applications: z.array(z.string()),
+    supersedes: catalogConnector.shape.supersedes,
+    min_schema: z.number().int().positive().optional(),
+    /** Content hash of the published definition file. */
+    hash: z.string(),
+});
+export const catalogIndex = obj({
+    schema_version: z.number().int().positive(),
+    generated_at: z.string(),
+    connectors: z.array(catalogIndexEntry),
+});
+export { wizardStep };

package/dist/schema/common.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import type { JSONSchema7 } from "json-schema";
+/**
+ * Every object schema in this package is loose: unknown keys are kept, not
+ * stripped. A consumer running an older copy of the schema must never drop a
+ * field a newer catalog added.
+ */
+export declare const obj: <T extends z.ZodRawShape>(shape: T) => z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$loose>;
+/** A JSONata expression. Evaluated by the platform, opaque here. */
+export declare const jsonata: z.ZodString;
+export declare const jsonSchema7: z.ZodCustom<JSONSchema7, JSONSchema7>;
+export declare const requiredScope: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    oneOf: z.ZodArray<z.ZodString>;
+}, z.core.$loose>]>;
+export declare const method: z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+}>;
+export type Method = z.infer<typeof method>;
+export declare const encryptedPayload: z.ZodObject<{
+    encryptedData: z.ZodString;
+    encryptedDek: z.ZodString;
+    iv: z.ZodString;
+    tag: z.ZodString;
+    gateway_id: z.ZodOptional<z.ZodString>;
+    kid: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type EncryptedPayload = z.infer<typeof encryptedPayload>;

package/dist/schema/common.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+/**
+ * Every object schema in this package is loose: unknown keys are kept, not
+ * stripped. A consumer running an older copy of the schema must never drop a
+ * field a newer catalog added.
+ */
+export const obj = (shape) => z.looseObject(shape);
+/** A JSONata expression. Evaluated by the platform, opaque here. */
+export const jsonata = z.string();
+export const jsonSchema7 = z.custom((value) => typeof value === "object" && value !== null, "Expected a JSON Schema object");
+export const requiredScope = z.union([
+    z.string(),
+    obj({ oneOf: z.array(z.string()) }),
+]);
+export const method = z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+export const encryptedPayload = obj({
+    encryptedData: z.string(),
+    encryptedDek: z.string(),
+    iv: z.string(),
+    tag: z.string(),
+    gateway_id: z.string().optional(),
+    kid: z.string().optional(),
+});

package/dist/schema/enums.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare enum ConnectorCategory {
+    COMMUNICATION_MESSAGING = "communication-messaging",
+    PROJECT_MANAGEMENT_ISSUE_TRACKING = "project-management-issue-tracking",
+    DOCUMENTATION_KNOWLEDGE_BASE = "documentation-knowledge-base",
+    CRM_SALES = "crm-sales",
+    CUSTOMER_SUPPORT_HELPDESK = "customer-support-helpdesk",
+    CODE_VERSION_CONTROL = "code-version-control",
+    CI_CD_DEVOPS = "ci-cd-devops",
+    CLOUD_INFRASTRUCTURE = "cloud-infrastructure",
+    DATABASES_DATA_WAREHOUSES = "databases-data-warehouses",
+    OBSERVABILITY_MONITORING = "observability-monitoring",
+    ANALYTICS_PRODUCT_INTELLIGENCE = "analytics-product-intelligence",
+    FILE_STORAGE_DOCUMENT_MANAGEMENT = "file-storage-document-management",
+    DESIGN_CREATIVE = "design-creative",
+    PAYMENTS_FINANCE = "payments-finance",
+    HR_PEOPLE_OPS = "hr-people-ops",
+    MARKETING_GROWTH = "marketing-growth",
+    IDENTITY_SECURITY = "identity-security",
+    SCHEDULING_CALENDAR = "scheduling-calendar",
+    SPREADSHEETS_NO_CODE_DATA = "spreadsheets-no-code-data",
+    WEB_SCRAPING_AUTOMATION = "web-scraping-automation",
+    OTHER = "other"
+}
+export declare enum ConnectorAuthType {
+    API_KEY = "apiKey",
+    OAUTH = "oauth",
+    WILLOW_OAUTH = "webrix-oauth",
+    SERVER_APP = "server-app",
+    SERVER_APP_PER_USER = "server-app-per-user",
+    PROXY_OAUTH = "proxy-oauth",
+    PROXY_CONNECTOR_OAUTH = "proxy-connector-oauth",
+    PROXY_API_KEY = "proxy-api-key",
+    PROXY_CLIENT_CREDENTIALS = "proxy-client-credentials",
+    PROXY_PASSTHROUGH = "proxy-passthrough",
+    API_KEY_PER_USER = "api-key-per-user",
+    CLIENT_CREDENTIALS = "client-credentials",
+    CLIENT_CREDENTIALS_PER_USER = "client-credentials-per-user",
+    NONE = "none"
+}
+export declare const connectorCategory: z.ZodEnum<typeof ConnectorCategory>;
+export declare const connectorAuthType: z.ZodEnum<typeof ConnectorAuthType>;

package/dist/schema/enums.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export var ConnectorCategory;
+(function (ConnectorCategory) {
+    ConnectorCategory["COMMUNICATION_MESSAGING"] = "communication-messaging";
+    ConnectorCategory["PROJECT_MANAGEMENT_ISSUE_TRACKING"] = "project-management-issue-tracking";
+    ConnectorCategory["DOCUMENTATION_KNOWLEDGE_BASE"] = "documentation-knowledge-base";
+    ConnectorCategory["CRM_SALES"] = "crm-sales";
+    ConnectorCategory["CUSTOMER_SUPPORT_HELPDESK"] = "customer-support-helpdesk";
+    ConnectorCategory["CODE_VERSION_CONTROL"] = "code-version-control";
+    ConnectorCategory["CI_CD_DEVOPS"] = "ci-cd-devops";
+    ConnectorCategory["CLOUD_INFRASTRUCTURE"] = "cloud-infrastructure";
+    ConnectorCategory["DATABASES_DATA_WAREHOUSES"] = "databases-data-warehouses";
+    ConnectorCategory["OBSERVABILITY_MONITORING"] = "observability-monitoring";
+    ConnectorCategory["ANALYTICS_PRODUCT_INTELLIGENCE"] = "analytics-product-intelligence";
+    ConnectorCategory["FILE_STORAGE_DOCUMENT_MANAGEMENT"] = "file-storage-document-management";
+    ConnectorCategory["DESIGN_CREATIVE"] = "design-creative";
+    ConnectorCategory["PAYMENTS_FINANCE"] = "payments-finance";
+    ConnectorCategory["HR_PEOPLE_OPS"] = "hr-people-ops";
+    ConnectorCategory["MARKETING_GROWTH"] = "marketing-growth";
+    ConnectorCategory["IDENTITY_SECURITY"] = "identity-security";
+    ConnectorCategory["SCHEDULING_CALENDAR"] = "scheduling-calendar";
+    ConnectorCategory["SPREADSHEETS_NO_CODE_DATA"] = "spreadsheets-no-code-data";
+    ConnectorCategory["WEB_SCRAPING_AUTOMATION"] = "web-scraping-automation";
+    ConnectorCategory["OTHER"] = "other";
+})(ConnectorCategory || (ConnectorCategory = {}));
+export var ConnectorAuthType;
+(function (ConnectorAuthType) {
+    ConnectorAuthType["API_KEY"] = "apiKey";
+    ConnectorAuthType["OAUTH"] = "oauth";
+    ConnectorAuthType["WILLOW_OAUTH"] = "webrix-oauth";
+    ConnectorAuthType["SERVER_APP"] = "server-app";
+    ConnectorAuthType["SERVER_APP_PER_USER"] = "server-app-per-user";
+    ConnectorAuthType["PROXY_OAUTH"] = "proxy-oauth";
+    ConnectorAuthType["PROXY_CONNECTOR_OAUTH"] = "proxy-connector-oauth";
+    ConnectorAuthType["PROXY_API_KEY"] = "proxy-api-key";
+    ConnectorAuthType["PROXY_CLIENT_CREDENTIALS"] = "proxy-client-credentials";
+    ConnectorAuthType["PROXY_PASSTHROUGH"] = "proxy-passthrough";
+    ConnectorAuthType["API_KEY_PER_USER"] = "api-key-per-user";
+    ConnectorAuthType["CLIENT_CREDENTIALS"] = "client-credentials";
+    ConnectorAuthType["CLIENT_CREDENTIALS_PER_USER"] = "client-credentials-per-user";
+    ConnectorAuthType["NONE"] = "none";
+})(ConnectorAuthType || (ConnectorAuthType = {}));
+export const connectorCategory = z.enum(ConnectorCategory);
+export const connectorAuthType = z.enum(ConnectorAuthType);

package/dist/schema/parts.d.ts

@@ -0,0 +1,123 @@
+import { z } from "zod";
+export declare const toolLabel: z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const conditionAction: z.ZodObject<{
+    path: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+    }>;
+    mapping: z.ZodObject<{
+        params: z.ZodOptional<z.ZodString>;
+        query: z.ZodOptional<z.ZodString>;
+        body: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const connectorCondition: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    action: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>;
+        mapping: z.ZodObject<{
+            params: z.ZodOptional<z.ZodString>;
+            query: z.ZodOptional<z.ZodString>;
+            body: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+    }, z.core.$loose>>;
+    mapping: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+    effect: z.ZodOptional<z.ZodEnum<{
+        block: "block";
+        warn: "warn";
+        require_approval: "require_approval";
+    }>>;
+    surface: z.ZodOptional<z.ZodEnum<{
+        tool: "tool";
+        webhook: "webhook";
+    }>>;
+    variables: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            "string[]": "string[]";
+            "number[]": "number[]";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodObject<{
+            action: z.ZodObject<{
+                path: z.ZodString;
+                method: z.ZodEnum<{
+                    GET: "GET";
+                    POST: "POST";
+                    PUT: "PUT";
+                    PATCH: "PATCH";
+                    DELETE: "DELETE";
+                }>;
+                mapping: z.ZodObject<{
+                    params: z.ZodOptional<z.ZodString>;
+                    query: z.ZodOptional<z.ZodString>;
+                    body: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>;
+            }, z.core.$loose>;
+            mapping: z.ZodString;
+            searchable: z.ZodOptional<z.ZodBoolean>;
+            searchParam: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+    appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export type ConnectorCondition = z.infer<typeof connectorCondition>;
+export declare const webhookSettings: z.ZodObject<{
+    verification: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"hmac-sha256">;
+        signatureHeader: z.ZodString;
+        signaturePrefix: z.ZodOptional<z.ZodString>;
+        timestampHeader: z.ZodOptional<z.ZodString>;
+        payloadTemplate: z.ZodOptional<z.ZodString>;
+        encoding: z.ZodOptional<z.ZodEnum<{
+            hex: "hex";
+            base64: "base64";
+        }>>;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, z.core.$loose>]>>;
+    challengeMapping: z.ZodOptional<z.ZodString>;
+    eventMapping: z.ZodOptional<z.ZodString>;
+    setupMarkdown: z.ZodOptional<z.ZodString>;
+    secretLabel: z.ZodOptional<z.ZodString>;
+    ignoreSelf: z.ZodOptional<z.ZodString>;
+    triggers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        match: z.ZodString;
+        sessionKey: z.ZodOptional<z.ZodString>;
+        exampleMapping: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** JSON-Schema-like description of connector-level configuration. */
+export declare const connectorConfiguration: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;

package/dist/schema/parts.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { jsonata, method, obj } from "./common.js";
+export const toolLabel = obj({
+    id: z.string(),
+    displayName: z.string(),
+    description: z.string().optional(),
+});
+const conditionVariableValue = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.string()),
+    z.array(z.number()),
+]);
+export const conditionAction = obj({
+    path: z.string(),
+    method,
+    mapping: obj({
+        params: jsonata.optional(),
+        query: jsonata.optional(),
+        body: jsonata.optional(),
+    }),
+});
+export const connectorCondition = obj({
+    id: z.string(),
+    name: z.string(),
+    description: z.string().optional(),
+    action: conditionAction.optional(),
+    mapping: jsonata,
+    message: z.string().optional(),
+    effect: z.enum(["block", "warn", "require_approval"]).optional(),
+    surface: z.enum(["tool", "webhook"]).optional(),
+    variables: z
+        .array(obj({
+        key: z.string(),
+        label: z.string(),
+        description: z.string().optional(),
+        type: z.enum(["string", "number", "boolean", "string[]", "number[]"]),
+        required: z.boolean().optional(),
+        default: conditionVariableValue.optional(),
+        placeholder: z.string().optional(),
+        options: obj({
+            action: conditionAction,
+            mapping: jsonata,
+            searchable: z.boolean().optional(),
+            searchParam: z.string().optional(),
+        }).optional(),
+    }))
+        .optional(),
+    appliesTo: z.array(z.string()).optional(),
+});
+export const webhookSettings = obj({
+    verification: z
+        .union([
+        obj({
+            type: z.literal("hmac-sha256"),
+            signatureHeader: z.string(),
+            signaturePrefix: z.string().optional(),
+            timestampHeader: z.string().optional(),
+            payloadTemplate: z.string().optional(),
+            encoding: z.enum(["hex", "base64"]).optional(),
+        }),
+        obj({ type: z.literal("none") }),
+    ])
+        .optional(),
+    challengeMapping: jsonata.optional(),
+    eventMapping: jsonata.optional(),
+    setupMarkdown: z.string().optional(),
+    secretLabel: z.string().optional(),
+    ignoreSelf: jsonata.optional(),
+    triggers: z.array(obj({
+        id: z.string(),
+        name: z.string(),
+        description: z.string().optional(),
+        match: jsonata,
+        sessionKey: jsonata.optional(),
+        exampleMapping: jsonata.optional(),
+    })),
+});
+/** JSON-Schema-like description of connector-level configuration. */
+export const connectorConfiguration = obj({
+    type: z.literal("object"),
+    properties: z.record(z.string(), z.record(z.string(), z.unknown())),
+    required: z.array(z.string()).optional(),
+});

package/dist/schema/tool.d.ts

@@ -0,0 +1,107 @@
+import { z } from "zod";
+export declare const toolSchemas: z.ZodObject<{
+    params: z.ZodOptional<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    query: z.ZodOptional<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    body: z.ZodOptional<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+    response: z.ZodOptional<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+}, z.core.$loose>;
+export declare const toolMapping: z.ZodObject<{
+    params: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    response: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodString>;
+    arguments: z.ZodOptional<z.ZodString>;
+    externalId: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const toolRiskLevel: z.ZodEnum<{
+    low: "low";
+    mid: "mid";
+    high: "high";
+}>;
+export declare const tool: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    slug: z.ZodString;
+    inputSchema: z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>;
+    enabled: z.ZodBoolean;
+    action: z.ZodObject<{
+        path: z.ZodString;
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>;
+        mapping: z.ZodObject<{
+            params: z.ZodOptional<z.ZodString>;
+            query: z.ZodOptional<z.ZodString>;
+            body: z.ZodOptional<z.ZodString>;
+            response: z.ZodOptional<z.ZodString>;
+            headers: z.ZodOptional<z.ZodString>;
+            arguments: z.ZodOptional<z.ZodString>;
+            externalId: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        responseType: z.ZodOptional<z.ZodEnum<{
+            json: "json";
+            text: "text";
+            arraybuffer: "arraybuffer";
+        }>>;
+        schemas: z.ZodOptional<z.ZodObject<{
+            params: z.ZodOptional<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+            query: z.ZodOptional<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+            body: z.ZodOptional<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+            response: z.ZodOptional<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+    annotations: z.ZodOptional<z.ZodObject<{
+        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+        destructiveHint: z.ZodOptional<z.ZodBoolean>;
+        idempotentHint: z.ZodOptional<z.ZodBoolean>;
+        openWorldHint: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    risk: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        mid: "mid";
+        high: "high";
+    }>>;
+    forceApproval: z.ZodOptional<z.ZodEnum<{
+        user: "user";
+        admin: "admin";
+    }>>;
+    requiredScopes: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        oneOf: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>]>>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export type Tool = z.infer<typeof tool>;
+/**
+ * Per-endpoint request/response schemas, keyed by path and method. Used by the
+ * tool builder to offer the provider's real shapes.
+ */
+export declare const endpointSchema: z.ZodObject<{
+    connectorSlug: z.ZodString;
+    path: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+    }>;
+    name: z.ZodString;
+    description: z.ZodString;
+    schemas: z.ZodObject<{
+        query: z.ZodOptional<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+        path: z.ZodOptional<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+        body: z.ZodOptional<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
+        responses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>>;
+    }, z.core.$loose>;
+    requiredScopes: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        oneOf: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>]>>>;
+}, z.core.$loose>;
+export type EndpointSchema = z.infer<typeof endpointSchema>;