@hachej/boring-mcp 0.1.78 → 0.1.79

package/dist/server/index.d.ts

@@ -2,6 +2,8 @@ import * as _hachej_boring_workspace from '@hachej/boring-workspace';
 import { ToolExecContext, AgentTool } from '@hachej/boring-workspace';
 import { McpActor, McpProviderId, McpToolCatalogEntry, McpToolSearchResult, McpToolDescribeResult, McpSourceRegistry, McpTransportClient, McpProviderTemplate, McpDiscoveredTool, McpReadonlyCallAuditEvent, McpReadonlyCallInput, McpReadonlyCallResult, McpSourceDto, McpSourceStatusPayload, McpDoctorResult, McpProbeResult, McpSource, McpErrorCode, McpConnectorRef, McpSourceStatus, McpDiscoveredResource } from '../shared/index.js';
 export { AIRTABLE_MCP_TEMPLATE, BORING_MCP_PLUGIN_ID, BORING_MCP_SOURCES_PANEL_ID, BORING_MCP_SOURCES_TAB_PANEL_ID, DEFAULT_MCP_PROVIDER_TEMPLATES, MCP_ERROR_CODES, MCP_TOOL_NAME_PATTERN, McpAccessFacade, McpCredentialProvider, McpDoctorIssue, McpError, McpSourceAccessPolicy, McpSourceOwnerKind, McpSourceStore, McpToolCallResult, McpToolDecision, McpToolRisk, McpTransport, McpTransportListToolsOptions, NOTION_MCP_TEMPLATE, NormalizedMcpTool, assertMcpToolAllowed, classifyMcpTool, classifyMcpTools, containsMcpCanary, containsMcpSecret, containsMcpSecretOrCanary, doctorMcpSource, getMcpProviderTemplate, redactMcpSecrets, toMcpSourceDto, validateMcpToolName } from '../shared/index.js';
+import { FastifyRequest } from 'fastify';
+import { CoreWorkspaceAgentServer } from '@hachej/boring-core/app/server';
 
 interface McpToolCatalogSnapshot {
     sourceId: string;
@@ -294,6 +296,77 @@ declare function createManagedConnectorSourceId(actor: McpActor, provider: McpPr
 declare function createLegacyManagedConnectorSourceId(actor: McpActor, provider: McpProviderId): string;
 declare function createManagedConnectorAdapter(options: ManagedConnectorAdapterOptions): ManagedConnectorAdapter;
 
+/** App server surface the boring-mcp binding depends on. */
+type BoringMcpAppServer = CoreWorkspaceAgentServer;
+/**
+ * Per-deployment configuration for the boring-mcp server binding. Everything a
+ * host used to hardcode when copying the glue lives here.
+ */
+interface BoringMcpBindingConfig {
+    /** Managed connector providers this deployment exposes. */
+    connectorConfigs: readonly ManagedConnectorConfig[];
+    /**
+     * Env var names checked (in order) for the Composio managed-connector API
+     * key. Defaults to `['COMPOSIO_API_KEY']`.
+     */
+    secretEnvVars?: readonly string[];
+    /** Redaction canary tokens forwarded to the managed connector adapter. */
+    redactionCanaries?: readonly string[];
+    /** Composio MCP transport client identity. */
+    clientName?: string;
+    clientVersion?: string;
+}
+interface BoringMcpServerRuntimeConfig {
+    enabled: boolean;
+    composioApiKeyConfigured: boolean;
+    maxReadonlyInputBytes: number;
+}
+declare function readBoringMcpServerConfig(env?: NodeJS.ProcessEnv, options?: {
+    secretEnvVars?: readonly string[];
+}): BoringMcpServerRuntimeConfig;
+interface CreateManagedConnectorSecretResolverOptions {
+    env?: NodeJS.ProcessEnv;
+    configs: readonly ManagedConnectorConfig[];
+    secretEnvVars?: readonly string[];
+}
+declare function createManagedConnectorSecretResolver(options: CreateManagedConnectorSecretResolverOptions): ManagedConnectorSecretResolver;
+interface CreateManagedConnectorAdapterOptions {
+    config: BoringMcpBindingConfig;
+    registry: ManagedConnectorSourceRegistry;
+    env?: NodeJS.ProcessEnv;
+    provider?: ManagedConnectorProvider;
+}
+declare function createBoringMcpManagedConnectorAdapter(options: CreateManagedConnectorAdapterOptions): ManagedConnectorAdapter;
+declare function boringMcpAgentSessionNamespace(ctx: {
+    workspaceId: string;
+    request?: FastifyRequest;
+    userId?: string;
+}): string;
+declare function createUserSettingsMcpSourceRegistry(app: Pick<BoringMcpAppServer, 'userStore' | 'config'>, actorScope: McpActor): ManagedConnectorSourceRegistry;
+interface CreateBoringMcpAppAgentToolsOptions {
+    config: BoringMcpBindingConfig;
+    env?: NodeJS.ProcessEnv;
+    transport?: McpTransportClient;
+}
+declare function createBoringMcpAppAgentTools(app: Pick<BoringMcpAppServer, 'userStore' | 'config'>, actor: McpActor, options: CreateBoringMcpAppAgentToolsOptions): AgentTool[];
+declare function createBoringMcpAppAgentToolsForRequest(app: Pick<BoringMcpAppServer, 'userStore' | 'config'>, ctx: {
+    workspaceId: string;
+    authSubject?: string;
+}, options: CreateBoringMcpAppAgentToolsOptions): AgentTool[];
+interface RegisterBoringMcpRoutesOptions {
+    config: BoringMcpBindingConfig;
+    provider?: ManagedConnectorProvider;
+    env?: NodeJS.ProcessEnv;
+    transport?: McpTransportClient;
+    /**
+     * Behavior when boring-mcp is disabled for this deployment.
+     * - `skip` (default): do not register the routes at all (client sees 404).
+     * - `serve-503`: always register; handlers reject with 503 while disabled.
+     */
+    whenDisabled?: 'skip' | 'serve-503';
+}
+declare function registerBoringMcpRoutes(app: BoringMcpAppServer, options: RegisterBoringMcpRoutesOptions): void;
+
 interface ComposioMcpSession {
     id: string;
     mcp: {
@@ -371,4 +444,4 @@ declare const _default: {
     agentTools: _hachej_boring_workspace.AgentTool[] | undefined;
 };
 
-export { BORING_MCP_AGENT_BRIDGE_TOOL_DEFINITIONS, BORING_MCP_AGENT_BRIDGE_TOOL_NAMES, type BoringMcpAgentBridgeContext, type BoringMcpAgentBridgeRegistry, type BoringMcpAgentBridgeTool, type BoringMcpAgentBridgeToolDefinition, type BoringMcpAgentBridgeToolName, type BoringMcpAgentToolActorResolver, type BoringMcpLaunchGateInput, type BoringMcpLaunchGateIssue, type BoringMcpLaunchGateIssueCode, type BoringMcpLaunchGateResult, type BoringMcpReadonlyCallOptions, type BoringMcpReadonlyCaller, type BoringMcpSourceHandlers, type BoringMcpSourceHandlersOptions, type BoringMcpToolCatalog, type BoringMcpToolCatalogOptions, type ComposioManagedConnectorProviderOptions, type ComposioMcpSession, type CreateBoringMcpAgentToolsOptions, type CreateBoringMcpServerPluginOptions, InMemoryMcpRateBudgetGate, type InMemoryMcpRateBudgetGateOptions, InMemoryMcpToolCatalogCache, type ManagedConnectorAcceptedGap, type ManagedConnectorAdapter, type ManagedConnectorAdapterOptions, type ManagedConnectorConfig, type ManagedConnectorPreflightCheck, type ManagedConnectorPreflightEvidence, type ManagedConnectorPreflightResult, type ManagedConnectorProbeResponse, type ManagedConnectorProvider, type ManagedConnectorRiskStatus, type ManagedConnectorSecret, type ManagedConnectorSecretResolver, type ManagedConnectorSecretStorage, type ManagedConnectorSourceRegistry, type ManagedConnectorStartInput, type ManagedConnectorStartResponse, type ManagedConnectorStartResult, type ManagedConnectorStatusResponse, type ManagedConnectorVendorRiskEvidence, McpActor, McpConnectorRef, McpDiscoveredResource, McpDiscoveredTool, McpDoctorResult, McpErrorCode, McpProbeResult, type McpProviderCallContext, type McpProviderHardeningOptions, McpProviderId, type McpProviderOperation, type McpProviderRateBudgetGate, McpProviderTemplate, McpReadonlyCallAuditEvent, type McpReadonlyCallAuditSink, McpReadonlyCallInput, McpReadonlyCallResult, type McpSdkEndpoint, type McpSdkEndpointResolverInput, type McpSdkTransportOptions, McpSource, McpSourceDto, McpSourceRegistry, McpSourceStatus, McpSourceStatusPayload, type McpToolCatalogCache, McpToolCatalogEntry, type McpToolDescribeInput, McpToolDescribeResult, McpToolSearchResult, type McpToolsSearchInput, McpTransportClient, type ResolveComposioMcpSessionInput, assertManagedConnectorPreflight, assertMcpPublicPayloadSecretFree, createBoringMcpAgentBridgeRegistry, createBoringMcpAgentTools, createBoringMcpReadonlyCaller, createBoringMcpServerPlugin, createBoringMcpSourceHandlers, createBoringMcpToolCatalog, createComposioManagedConnectorProvider, createComposioMcpTransport, createHardenedMcpTransport, createLegacyManagedConnectorSourceId, createManagedConnectorAdapter, createManagedConnectorSourceId, createMcpSchemaHash, createMcpSdkStreamableHttpTransport, createMcpSourceStatusPayload, _default as default, evaluateBoringMcpLaunchGate, isActorOwnedMcpSource, listBoringMcpAgentBridgeTools, normalizeMcpCatalogTool, requireActorOwnedMcpSource, resolveComposioMcpSession, validateManagedConnectorPreflight, validateMcpSourceId, verifyMcpDisconnectResult };
+export { BORING_MCP_AGENT_BRIDGE_TOOL_DEFINITIONS, BORING_MCP_AGENT_BRIDGE_TOOL_NAMES, type BoringMcpAgentBridgeContext, type BoringMcpAgentBridgeRegistry, type BoringMcpAgentBridgeTool, type BoringMcpAgentBridgeToolDefinition, type BoringMcpAgentBridgeToolName, type BoringMcpAgentToolActorResolver, type BoringMcpAppServer, type BoringMcpBindingConfig, type BoringMcpLaunchGateInput, type BoringMcpLaunchGateIssue, type BoringMcpLaunchGateIssueCode, type BoringMcpLaunchGateResult, type BoringMcpReadonlyCallOptions, type BoringMcpReadonlyCaller, type BoringMcpServerRuntimeConfig, type BoringMcpSourceHandlers, type BoringMcpSourceHandlersOptions, type BoringMcpToolCatalog, type BoringMcpToolCatalogOptions, type ComposioManagedConnectorProviderOptions, type ComposioMcpSession, type CreateBoringMcpAgentToolsOptions, type CreateBoringMcpAppAgentToolsOptions, type CreateBoringMcpServerPluginOptions, type CreateManagedConnectorAdapterOptions, type CreateManagedConnectorSecretResolverOptions, InMemoryMcpRateBudgetGate, type InMemoryMcpRateBudgetGateOptions, InMemoryMcpToolCatalogCache, type ManagedConnectorAcceptedGap, type ManagedConnectorAdapter, type ManagedConnectorAdapterOptions, type ManagedConnectorConfig, type ManagedConnectorPreflightCheck, type ManagedConnectorPreflightEvidence, type ManagedConnectorPreflightResult, type ManagedConnectorProbeResponse, type ManagedConnectorProvider, type ManagedConnectorRiskStatus, type ManagedConnectorSecret, type ManagedConnectorSecretResolver, type ManagedConnectorSecretStorage, type ManagedConnectorSourceRegistry, type ManagedConnectorStartInput, type ManagedConnectorStartResponse, type ManagedConnectorStartResult, type ManagedConnectorStatusResponse, type ManagedConnectorVendorRiskEvidence, McpActor, McpConnectorRef, McpDiscoveredResource, McpDiscoveredTool, McpDoctorResult, McpErrorCode, McpProbeResult, type McpProviderCallContext, type McpProviderHardeningOptions, McpProviderId, type McpProviderOperation, type McpProviderRateBudgetGate, McpProviderTemplate, McpReadonlyCallAuditEvent, type McpReadonlyCallAuditSink, McpReadonlyCallInput, McpReadonlyCallResult, type McpSdkEndpoint, type McpSdkEndpointResolverInput, type McpSdkTransportOptions, McpSource, McpSourceDto, McpSourceRegistry, McpSourceStatus, McpSourceStatusPayload, type McpToolCatalogCache, McpToolCatalogEntry, type McpToolDescribeInput, McpToolDescribeResult, McpToolSearchResult, type McpToolsSearchInput, McpTransportClient, type RegisterBoringMcpRoutesOptions, type ResolveComposioMcpSessionInput, assertManagedConnectorPreflight, assertMcpPublicPayloadSecretFree, boringMcpAgentSessionNamespace, createBoringMcpAgentBridgeRegistry, createBoringMcpAgentTools, createBoringMcpAppAgentTools, createBoringMcpAppAgentToolsForRequest, createBoringMcpManagedConnectorAdapter, createBoringMcpReadonlyCaller, createBoringMcpServerPlugin, createBoringMcpSourceHandlers, createBoringMcpToolCatalog, createComposioManagedConnectorProvider, createComposioMcpTransport, createHardenedMcpTransport, createLegacyManagedConnectorSourceId, createManagedConnectorAdapter, createManagedConnectorSecretResolver, createManagedConnectorSourceId, createMcpSchemaHash, createMcpSdkStreamableHttpTransport, createMcpSourceStatusPayload, createUserSettingsMcpSourceRegistry, _default as default, evaluateBoringMcpLaunchGate, isActorOwnedMcpSource, listBoringMcpAgentBridgeTools, normalizeMcpCatalogTool, readBoringMcpServerConfig, registerBoringMcpRoutes, requireActorOwnedMcpSource, resolveComposioMcpSession, validateManagedConnectorPreflight, validateMcpSourceId, verifyMcpDisconnectResult };

package/dist/server/index.js

@@ -883,6 +883,149 @@ function createBoringMcpAgentTools(options) {
   }));
 }
 
+// src/server/appServerBinding.ts
+import { createHash as createHash3 } from "crypto";
+import { HttpError, ERROR_CODES } from "@hachej/boring-core/shared";
+import { withUserSettingsWriteLock } from "@hachej/boring-core/server";
+
+// src/server/managedConnectorAdapter.ts
+import { createHash as createHash2 } from "crypto";
+function findConfig(configs, provider) {
+  return configs.find((config) => config.provider === provider);
+}
+function createManagedConnectorSourceId(actor, provider) {
+  const digest = createHash2("sha256").update(`${actor.workspaceId}\0${actor.userId}\0${provider}`).digest("hex").slice(0, 32);
+  return validateMcpSourceId(`managed:${provider}:${digest}`);
+}
+function createLegacyManagedConnectorSourceId(actor, provider) {
+  return validateMcpSourceId(`managed:${actor.workspaceId}:${actor.userId}:${provider}`);
+}
+function defaultSourceId(actor, config) {
+  return createManagedConnectorSourceId(actor, config.provider);
+}
+function assertSecretFree(value, canaries, code = MCP_ERROR_CODES.SECRET_LEAK_GUARD) {
+  if (containsMcpSecretOrCanary(value, canaries)) {
+    throw new McpError(code, "Managed connector response contained secret material");
+  }
+}
+function safeConnectUrl(rawUrl, config) {
+  if (!rawUrl) return void 0;
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector returned an invalid connect URL");
+  }
+  if (parsed.protocol !== "https:" || parsed.username || parsed.password) {
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector returned an unsafe connect URL");
+  }
+  if (config.connectUrlOrigins?.length && !config.connectUrlOrigins.includes(parsed.origin)) {
+    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector returned an unapproved connect URL origin");
+  }
+  return parsed.toString();
+}
+function createManagedConnectorAdapter(options) {
+  const canaries = [...options.preflightEvidence?.redactionCanaries ?? [], ...options.redactionCanaries ?? []];
+  const templates = options.templates;
+  async function getSecret(provider) {
+    const secret = await options.secretResolver.resolveSecret(provider);
+    if (secret.storage !== "server-env" && secret.storage !== "server-vault" || !secret.value) {
+      throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector secret is not configured");
+    }
+    return secret;
+  }
+  function requireConfig(provider) {
+    const config = findConfig(options.configs, provider);
+    const template = getMcpProviderTemplate(provider, templates);
+    if (!config || !template) throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Unknown managed connector provider", { reason: "unsupported_provider" });
+    return { config, template };
+  }
+  return {
+    async startConnect(actor, input) {
+      const { config } = requireConfig(input.provider);
+      const sourceId = validateMcpSourceId((options.sourceIdFactory ?? defaultSourceId)(actor, config));
+      const secret = await getSecret(config.provider);
+      const secretCanaries = [...canaries, secret.value];
+      const response = await options.provider.startConnect({ actor, config, secret, sourceId });
+      const connectUrl = safeConnectUrl(response.connectUrl, config);
+      assertSecretFree({ ...response, connectUrl }, secretCanaries);
+      const source = {
+        id: sourceId,
+        workspaceId: actor.workspaceId,
+        userId: actor.userId,
+        provider: config.provider,
+        displayName: input.displayName ?? config.displayName,
+        status: response.status ?? "unconfigured",
+        ownerKind: "user",
+        credentialProvider: "composio-managed",
+        scopes: config.scopes ? [...config.scopes] : void 0,
+        providerAccountLabel: response.providerAccountLabel,
+        connectorRef: response.connectorRef
+      };
+      assertSecretFree(source, secretCanaries);
+      const saved = await options.registry.upsertSource(actor, source);
+      const result = { ...createMcpSourceStatusPayload(saved), connectUrl };
+      assertSecretFree(result, secretCanaries);
+      return result;
+    },
+    async refreshStatus(actor, sourceId) {
+      const source = await requireActorOwnedMcpSource(options.registry, actor, sourceId);
+      const { config } = requireConfig(source.provider);
+      const secret = await getSecret(config.provider);
+      const secretCanaries = [...canaries, secret.value];
+      const response = await options.provider.refreshStatus({ actor, source, config, secret });
+      assertSecretFree(response, secretCanaries);
+      const nextSource = {
+        ...source,
+        status: response.status,
+        providerAccountLabel: response.providerAccountLabel ?? source.providerAccountLabel,
+        connectorRef: response.connectorRef ?? source.connectorRef,
+        lastVerifiedAt: response.lastVerifiedAt
+      };
+      assertSecretFree(nextSource, secretCanaries);
+      const saved = await options.registry.upsertSource(actor, nextSource);
+      const result = createMcpSourceStatusPayload(saved);
+      assertSecretFree(result, secretCanaries);
+      return result;
+    },
+    async probeSource(actor, sourceId) {
+      const source = await requireActorOwnedMcpSource(options.registry, actor, sourceId);
+      if (source.status !== "connected") throw new McpError(MCP_ERROR_CODES.SOURCE_UNAVAILABLE, "MCP source is not connected");
+      const { config, template } = requireConfig(source.provider);
+      const secret = await getSecret(config.provider);
+      const response = await options.provider.probe({ actor, source, config, secret });
+      assertSecretFree(response, [...canaries, secret.value]);
+      const result = {
+        sourceId: source.id,
+        provider: source.provider,
+        tools: classifyMcpTools(template, response.tools),
+        resources: response.resources
+      };
+      assertSecretFree(result, [...canaries, secret.value]);
+      return result;
+    },
+    async disconnectSource(actor, sourceId) {
+      if (!options.registry.disconnectSource) throw new McpError(MCP_ERROR_CODES.SOURCE_UNAVAILABLE, "MCP source disconnect is not configured");
+      const source = await requireActorOwnedMcpSource(options.registry, actor, sourceId);
+      let secretCanaries = canaries;
+      if (options.provider.revoke) {
+        try {
+          const { config } = requireConfig(source.provider);
+          const secret = await getSecret(config.provider);
+          await options.provider.revoke({ actor, source, config, secret });
+          secretCanaries = [...canaries, secret.value];
+        } catch (error) {
+          if (!(error instanceof McpError && error.code === MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID)) throw error;
+        }
+      }
+      const disconnected = await options.registry.disconnectSource(actor, source.id);
+      const result = await verifyMcpDisconnectResult(options.registry, actor, source.id, disconnected);
+      assertSecretFree(result, secretCanaries);
+      return result;
+    }
+  };
+}
+
 // src/server/mcpSdkTransport.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -1364,143 +1507,413 @@ function createComposioMcpTransport(options) {
   };
 }
 
-// src/server/managedConnectorAdapter.ts
-import { createHash as createHash2 } from "crypto";
-function findConfig(configs, provider) {
-  return configs.find((config) => config.provider === provider);
+// src/server/appServerBinding.ts
+var DEFAULT_MAX_READONLY_INPUT_BYTES = 64 * 1024;
+var MAX_READONLY_INPUT_BYTES = 1024 * 1024;
+var SOURCE_CONNECT_RATE_LIMIT = { max: 10, timeWindow: "1 minute" };
+var SOURCE_ACTION_RATE_LIMIT = { max: 60, timeWindow: "1 minute" };
+var DEFAULT_SECRET_ENV_VARS = ["COMPOSIO_API_KEY"];
+function resolveSecretEnvVars(config) {
+  return config.secretEnvVars && config.secretEnvVars.length > 0 ? config.secretEnvVars : DEFAULT_SECRET_ENV_VARS;
+}
+function resolveComposioSecret(env, secretEnvVars) {
+  for (const name of secretEnvVars) {
+    const value = env[name]?.trim();
+    if (value) return value;
+  }
+  return void 0;
 }
-function createManagedConnectorSourceId(actor, provider) {
-  const digest = createHash2("sha256").update(`${actor.workspaceId}\0${actor.userId}\0${provider}`).digest("hex").slice(0, 32);
-  return validateMcpSourceId(`managed:${provider}:${digest}`);
+function parseReadonlyInputLimit(value) {
+  if (!value) return DEFAULT_MAX_READONLY_INPUT_BYTES;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > MAX_READONLY_INPUT_BYTES) return DEFAULT_MAX_READONLY_INPUT_BYTES;
+  return parsed;
 }
-function createLegacyManagedConnectorSourceId(actor, provider) {
-  return validateMcpSourceId(`managed:${actor.workspaceId}:${actor.userId}:${provider}`);
+function readBoringMcpServerConfig(env = process.env, options = {}) {
+  const productionEnabled = env.BORING_MCP_PROD_ENABLED === "1";
+  const nonProductionEnabled = env.BORING_MCP_ENABLED !== "0";
+  const secretEnvVars = resolveSecretEnvVars(options);
+  return {
+    enabled: env.NODE_ENV === "production" ? productionEnabled : nonProductionEnabled,
+    composioApiKeyConfigured: Boolean(resolveComposioSecret(env, secretEnvVars)),
+    maxReadonlyInputBytes: parseReadonlyInputLimit(env.BORING_MCP_MAX_READONLY_INPUT_BYTES)
+  };
 }
-function defaultSourceId(actor, config) {
-  return createManagedConnectorSourceId(actor, config.provider);
+function createManagedConnectorSecretResolver(options) {
+  const env = options.env ?? process.env;
+  const secretEnvVars = resolveSecretEnvVars(options);
+  const supportedProviders = new Set(options.configs.map((config) => config.provider));
+  return {
+    async resolveSecret(provider) {
+      if (!supportedProviders.has(provider)) {
+        throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, `Unsupported MCP provider: ${provider}`, { reason: "unsupported_provider" });
+      }
+      const value = resolveComposioSecret(env, secretEnvVars);
+      if (!value) {
+        throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, `${secretEnvVars.join("/")} is not configured`);
+      }
+      return { storage: "server-env", value };
+    }
+  };
 }
-function assertSecretFree(value, canaries, code = MCP_ERROR_CODES.SECRET_LEAK_GUARD) {
-  if (containsMcpSecretOrCanary(value, canaries)) {
-    throw new McpError(code, "Managed connector response contained secret material");
+function createBoringMcpManagedConnectorAdapter(options) {
+  return createManagedConnectorAdapter({
+    registry: options.registry,
+    provider: options.provider ?? createComposioManagedConnectorProvider(),
+    secretResolver: createManagedConnectorSecretResolver({
+      env: options.env,
+      configs: options.config.connectorConfigs,
+      secretEnvVars: options.config.secretEnvVars
+    }),
+    templates: DEFAULT_MCP_PROVIDER_TEMPLATES,
+    redactionCanaries: options.config.redactionCanaries,
+    configs: options.config.connectorConfigs
+  });
+}
+var USER_SETTINGS_MCP_SOURCES_KEY = "__serverBoringMcpSourcesV1";
+var WORKSPACE_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+function requestUserId(request) {
+  const user = request?.user;
+  return typeof user?.id === "string" && user.id.trim() ? user.id : void 0;
+}
+function shortHash(value) {
+  return createHash3("sha256").update(value).digest("hex").slice(0, 16);
+}
+function safeSessionNamespaceSegment(value) {
+  return value.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 80) || "workspace";
+}
+function boringMcpAgentSessionNamespace(ctx) {
+  const workspaceSegment = safeSessionNamespaceSegment(ctx.workspaceId);
+  const userId = ctx.userId?.trim() || requestUserId(ctx.request);
+  return `${workspaceSegment}_user_${userId ? shortHash(userId) : "anonymous"}`;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function parseString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function validateWorkspaceId(value, requestId) {
+  const workspaceId = parseString(value);
+  if (!workspaceId || !WORKSPACE_ID_PATTERN.test(workspaceId)) {
+    throw new HttpError({ status: 400, code: ERROR_CODES.VALIDATION_FAILED, message: "Invalid workspace id", requestId });
+  }
+  return workspaceId;
+}
+function routeError(status, code, message, requestId) {
+  return new HttpError({ status, code, message, requestId });
+}
+function mcpHttpStatus(error) {
+  switch (error.code) {
+    case MCP_ERROR_CODES.SOURCE_NOT_FOUND:
+    case MCP_ERROR_CODES.TOOL_NOT_FOUND:
+      return { status: 404, code: ERROR_CODES.NOT_FOUND };
+    case MCP_ERROR_CODES.SOURCE_FORBIDDEN:
+      return { status: 403, code: ERROR_CODES.FORBIDDEN };
+    case MCP_ERROR_CODES.INPUT_INVALID:
+    case MCP_ERROR_CODES.RESOURCE_URI_INVALID:
+    case MCP_ERROR_CODES.PROVIDER_TOOL_DRIFT:
+    case MCP_ERROR_CODES.TOOL_NOT_ALLOWED:
+      return { status: 400, code: ERROR_CODES.VALIDATION_FAILED };
+    case MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID:
+      return asRecord(error.details).reason === "unsupported_provider" ? { status: 400, code: ERROR_CODES.VALIDATION_FAILED } : { status: 503, code: ERROR_CODES.CONFIG_VALIDATION_FAILED };
+    case MCP_ERROR_CODES.SOURCE_UNAVAILABLE:
+      return { status: 409, code: ERROR_CODES.VALIDATION_FAILED };
+    case MCP_ERROR_CODES.RESOURCE_LIMIT_EXCEEDED:
+      return { status: 413, code: ERROR_CODES.VALIDATION_FAILED };
+    case MCP_ERROR_CODES.PROVIDER_TIMEOUT:
+      return { status: 504, code: ERROR_CODES.INTERNAL_ERROR };
+    case MCP_ERROR_CODES.PROVIDER_ERROR:
+      return { status: 502, code: ERROR_CODES.INTERNAL_ERROR };
+    case MCP_ERROR_CODES.SECRET_LEAK_GUARD:
+      return { status: 500, code: ERROR_CODES.INTERNAL_ERROR };
+    default:
+      return { status: 500, code: ERROR_CODES.INTERNAL_ERROR };
+  }
+}
+async function withMcpHttpErrors(requestId, fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (error instanceof McpError) {
+      const mapped = mcpHttpStatus(error);
+      throw routeError(mapped.status, mapped.code, error.message, requestId);
+    }
+    throw error;
   }
 }
-function safeConnectUrl(rawUrl, config) {
-  if (!rawUrl) return void 0;
-  let parsed;
+function sourceFromUnknown(value) {
+  const record2 = asRecord(value);
+  const id = parseString(record2.id);
+  const workspaceId = parseString(record2.workspaceId);
+  const userId = parseString(record2.userId);
+  const provider = parseString(record2.provider);
+  const displayName2 = parseString(record2.displayName);
+  const status = parseString(record2.status);
+  const ownerKind = parseString(record2.ownerKind);
+  const credentialProvider = parseString(record2.credentialProvider);
+  if (!id || !workspaceId || !userId || !provider || !displayName2 || !status || !ownerKind || !credentialProvider) return void 0;
+  if (!["connected", "expired", "revoked", "error", "unconfigured"].includes(status)) return void 0;
+  return {
+    id,
+    workspaceId,
+    userId,
+    provider,
+    displayName: displayName2,
+    status,
+    ownerKind,
+    credentialProvider,
+    scopes: Array.isArray(record2.scopes) ? record2.scopes.filter((item) => typeof item === "string") : void 0,
+    providerAccountLabel: parseString(record2.providerAccountLabel),
+    connectorRef: asRecord(record2.connectorRef),
+    lastVerifiedAt: parseString(record2.lastVerifiedAt),
+    createdAt: parseString(record2.createdAt),
+    updatedAt: parseString(record2.updatedAt)
+  };
+}
+function readRawStoredSources(settings, actor) {
+  const root = asRecord(settings[USER_SETTINGS_MCP_SOURCES_KEY]);
+  const workspaceSources = asRecord(root[actor.workspaceId]);
+  return Object.values(workspaceSources).map(sourceFromUnknown).filter((source) => Boolean(source && source.workspaceId === actor.workspaceId && source.userId === actor.userId));
+}
+function normalizeStoredSourceId(actor, source) {
   try {
-    parsed = new URL(rawUrl);
+    const legacyId = createLegacyManagedConnectorSourceId(actor, source.provider);
+    return source.id === legacyId ? { ...source, id: createManagedConnectorSourceId(actor, source.provider) } : source;
   } catch {
-    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector returned an invalid connect URL");
-  }
-  if (parsed.protocol !== "https:" || parsed.username || parsed.password) {
-    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector returned an unsafe connect URL");
-  }
-  if (config.connectUrlOrigins?.length && !config.connectUrlOrigins.includes(parsed.origin)) {
-    throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector returned an unapproved connect URL origin");
+    return source;
   }
-  return parsed.toString();
 }
-function createManagedConnectorAdapter(options) {
-  const canaries = [...options.preflightEvidence?.redactionCanaries ?? [], ...options.redactionCanaries ?? []];
-  const templates = options.templates;
-  async function getSecret(provider) {
-    const secret = await options.secretResolver.resolveSecret(provider);
-    if (secret.storage !== "server-env" && secret.storage !== "server-vault" || !secret.value) {
-      throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Managed connector secret is not configured");
-    }
-    return secret;
+function sourceStatusRank(source) {
+  switch (source.status) {
+    case "connected":
+      return 5;
+    case "expired":
+    case "error":
+      return 4;
+    case "unconfigured":
+      return 3;
+    case "revoked":
+      return 1;
+    default:
+      return 0;
   }
-  function requireConfig(provider) {
-    const config = findConfig(options.configs, provider);
-    const template = getMcpProviderTemplate(provider, templates);
-    if (!config || !template) throw new McpError(MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID, "Unknown managed connector provider", { reason: "unsupported_provider" });
-    return { config, template };
+}
+function dedupeStoredSources(sources) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const current = byId.get(source.id);
+    if (!current || sourceStatusRank(source) >= sourceStatusRank(current)) byId.set(source.id, source);
   }
+  return [...byId.values()];
+}
+function readStoredSources(settings, actor) {
+  return dedupeStoredSources(readRawStoredSources(settings, actor).map((source) => normalizeStoredSourceId(actor, source)));
+}
+function existingLegacySourceIdFor(actor, source, rawSources) {
+  try {
+    const legacyId = createLegacyManagedConnectorSourceId(actor, source.provider);
+    return legacyId !== source.id && rawSources.some((item) => item.id === legacyId) ? legacyId : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function saveStoredSource(app, actor, source, removeSourceIds = []) {
+  const patch = app.userStore.patchUserSettingsJsonPath;
+  if (patch && removeSourceIds.length === 0) {
+    const updated = await patch.call(
+      app.userStore,
+      actor.userId,
+      app.config.appId,
+      [USER_SETTINGS_MCP_SOURCES_KEY, actor.workspaceId, source.id],
+      source
+    );
+    return readStoredSources(updated.settings, actor);
+  }
+  return await withUserSettingsWriteLock(actor.userId, app.config.appId, async () => {
+    const current = await app.userStore.getUserSettings(actor.userId, app.config.appId);
+    const root = asRecord(current.settings[USER_SETTINGS_MCP_SOURCES_KEY]);
+    const removeIds = /* @__PURE__ */ new Set([source.id, ...removeSourceIds]);
+    const sources = readRawStoredSources(current.settings, actor);
+    const nextSources = [...sources.filter((item) => !removeIds.has(item.id)), source];
+    const nextSettings = {
+      ...current.settings,
+      [USER_SETTINGS_MCP_SOURCES_KEY]: {
+        ...root,
+        [actor.workspaceId]: Object.fromEntries(nextSources.map((item) => [item.id, item]))
+      }
+    };
+    await app.userStore.putUserSettings(actor.userId, app.config.appId, { settings: nextSettings });
+    return readStoredSources(nextSettings, actor);
+  });
+}
+function createUserSettingsMcpSourceRegistry(app, actorScope) {
   return {
-    async startConnect(actor, input) {
-      const { config } = requireConfig(input.provider);
-      const sourceId = validateMcpSourceId((options.sourceIdFactory ?? defaultSourceId)(actor, config));
-      const secret = await getSecret(config.provider);
-      const secretCanaries = [...canaries, secret.value];
-      const response = await options.provider.startConnect({ actor, config, secret, sourceId });
-      const connectUrl = safeConnectUrl(response.connectUrl, config);
-      assertSecretFree({ ...response, connectUrl }, secretCanaries);
-      const source = {
-        id: sourceId,
-        workspaceId: actor.workspaceId,
-        userId: actor.userId,
-        provider: config.provider,
-        displayName: input.displayName ?? config.displayName,
-        status: response.status ?? "unconfigured",
-        ownerKind: "user",
-        credentialProvider: "composio-managed",
-        scopes: config.scopes ? [...config.scopes] : void 0,
-        providerAccountLabel: response.providerAccountLabel,
-        connectorRef: response.connectorRef
-      };
-      assertSecretFree(source, secretCanaries);
-      const saved = await options.registry.upsertSource(actor, source);
-      const result = { ...createMcpSourceStatusPayload(saved), connectUrl };
-      assertSecretFree(result, secretCanaries);
-      return result;
+    async listSources(actor) {
+      const current = await app.userStore.getUserSettings(actor.userId, app.config.appId);
+      return readStoredSources(current.settings, actor);
     },
-    async refreshStatus(actor, sourceId) {
-      const source = await requireActorOwnedMcpSource(options.registry, actor, sourceId);
-      const { config } = requireConfig(source.provider);
-      const secret = await getSecret(config.provider);
-      const secretCanaries = [...canaries, secret.value];
-      const response = await options.provider.refreshStatus({ actor, source, config, secret });
-      assertSecretFree(response, secretCanaries);
-      const nextSource = {
-        ...source,
-        status: response.status,
-        providerAccountLabel: response.providerAccountLabel ?? source.providerAccountLabel,
-        connectorRef: response.connectorRef ?? source.connectorRef,
-        lastVerifiedAt: response.lastVerifiedAt
-      };
-      assertSecretFree(nextSource, secretCanaries);
-      const saved = await options.registry.upsertSource(actor, nextSource);
-      const result = createMcpSourceStatusPayload(saved);
-      assertSecretFree(result, secretCanaries);
-      return result;
+    async getSource(sourceId) {
+      const current = await app.userStore.getUserSettings(actorScope.userId, app.config.appId);
+      const source = readStoredSources(current.settings, actorScope).find((item) => item.id === sourceId);
+      if (source) return source;
+      const legacySource = readRawStoredSources(current.settings, actorScope).find((item) => item.id === sourceId);
+      return legacySource ? normalizeStoredSourceId(actorScope, legacySource) : void 0;
     },
-    async probeSource(actor, sourceId) {
-      const source = await requireActorOwnedMcpSource(options.registry, actor, sourceId);
-      if (source.status !== "connected") throw new McpError(MCP_ERROR_CODES.SOURCE_UNAVAILABLE, "MCP source is not connected");
-      const { config, template } = requireConfig(source.provider);
-      const secret = await getSecret(config.provider);
-      const response = await options.provider.probe({ actor, source, config, secret });
-      assertSecretFree(response, [...canaries, secret.value]);
-      const result = {
-        sourceId: source.id,
-        provider: source.provider,
-        tools: classifyMcpTools(template, response.tools),
-        resources: response.resources
-      };
-      assertSecretFree(result, [...canaries, secret.value]);
-      return result;
+    async upsertSource(actor, source) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const currentSettings = await app.userStore.getUserSettings(actor.userId, app.config.appId);
+      const current = readStoredSources(currentSettings.settings, actor);
+      const rawSources = readRawStoredSources(currentSettings.settings, actor);
+      const existing = current.find((item) => item.id === source.id);
+      const next = { ...source, updatedAt: now, createdAt: source.createdAt ?? existing?.createdAt ?? now };
+      const legacyId = existingLegacySourceIdFor(actor, next, rawSources);
+      await saveStoredSource(app, actor, next, legacyId ? [legacyId] : []);
+      return next;
     },
     async disconnectSource(actor, sourceId) {
-      if (!options.registry.disconnectSource) throw new McpError(MCP_ERROR_CODES.SOURCE_UNAVAILABLE, "MCP source disconnect is not configured");
-      const source = await requireActorOwnedMcpSource(options.registry, actor, sourceId);
-      let secretCanaries = canaries;
-      if (options.provider.revoke) {
-        try {
-          const { config } = requireConfig(source.provider);
-          const secret = await getSecret(config.provider);
-          await options.provider.revoke({ actor, source, config, secret });
-          secretCanaries = [...canaries, secret.value];
-        } catch (error) {
-          if (!(error instanceof McpError && error.code === MCP_ERROR_CODES.PROVIDER_CONFIG_INVALID)) throw error;
-        }
-      }
-      const disconnected = await options.registry.disconnectSource(actor, source.id);
-      const result = await verifyMcpDisconnectResult(options.registry, actor, source.id, disconnected);
-      assertSecretFree(result, secretCanaries);
-      return result;
+      const currentSettings = await app.userStore.getUserSettings(actor.userId, app.config.appId);
+      const source = readStoredSources(currentSettings.settings, actor).find((item) => item.id === sourceId) ?? (() => {
+        const legacySource = readRawStoredSources(currentSettings.settings, actor).find((item) => item.id === sourceId);
+        return legacySource ? normalizeStoredSourceId(actor, legacySource) : void 0;
+      })();
+      if (!source) return void 0;
+      const disconnected = { ...source, status: "revoked", updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      const legacyId = existingLegacySourceIdFor(actor, disconnected, readRawStoredSources(currentSettings.settings, actor));
+      await saveStoredSource(app, actor, disconnected, legacyId ? [legacyId] : []);
+      return disconnected;
     }
   };
 }
+function createComposioMcpTransportFor(config, env) {
+  return createComposioMcpTransport({
+    secretResolver: createManagedConnectorSecretResolver({ env, configs: config.connectorConfigs, secretEnvVars: config.secretEnvVars }),
+    configs: config.connectorConfigs,
+    clientName: config.clientName ?? "boring-mcp",
+    clientVersion: config.clientVersion ?? "0.0.0"
+  });
+}
+function createBoringMcpAppAgentTools(app, actor, options) {
+  const runtimeConfig = readBoringMcpServerConfig(options.env, { secretEnvVars: options.config.secretEnvVars });
+  if (!runtimeConfig.enabled) return [];
+  const registry = createUserSettingsMcpSourceRegistry(app, actor);
+  const transport = options.transport ?? createComposioMcpTransportFor(options.config, options.env);
+  return createBoringMcpAgentTools({
+    registry,
+    transport,
+    resolveActor: () => actor,
+    templates: DEFAULT_MCP_PROVIDER_TEMPLATES,
+    hardening: { gate: new InMemoryMcpRateBudgetGate({ maxCalls: 100, maxToolCalls: 10, windowMs: 6e4 }), timeoutMs: 3e4 },
+    maxReadonlyInputBytes: runtimeConfig.maxReadonlyInputBytes
+  });
+}
+function createBoringMcpAppAgentToolsForRequest(app, ctx, options) {
+  const userId = typeof ctx.authSubject === "string" && ctx.authSubject.trim() ? ctx.authSubject.trim() : void 0;
+  if (!userId) return [];
+  return createBoringMcpAppAgentTools(app, { workspaceId: ctx.workspaceId, userId }, options);
+}
+async function requireBoringMcpActor(app, request) {
+  const body = asRecord(request.body);
+  const query = asRecord(request.query);
+  const workspaceId = validateWorkspaceId(
+    request.headers["x-boring-workspace-id"] ?? body.workspaceId ?? query.workspaceId,
+    request.id
+  );
+  const user = request.user;
+  if (!user) throw routeError(401, ERROR_CODES.UNAUTHORIZED, "Authentication required", request.id);
+  const workspace = await app.workspaceStore.get(workspaceId);
+  if (!workspace || workspace.appId !== app.config.appId) throw routeError(404, ERROR_CODES.NOT_FOUND, "Workspace not found", request.id);
+  const role = await app.workspaceStore.getMemberRole(workspaceId, user.id);
+  if (!role) throw routeError(403, ERROR_CODES.NOT_MEMBER, "Not a member of this workspace", request.id);
+  return { workspaceId, userId: user.id };
+}
+function sourceActionRateLimitKey(request) {
+  const workspaceId = typeof request.headers["x-boring-workspace-id"] === "string" ? request.headers["x-boring-workspace-id"] : "unknown-workspace";
+  return `${request.user?.id ?? request.ip}:${workspaceId}`;
+}
+function sourceIdFromBody(body, requestId) {
+  const sourceId = parseString(asRecord(body).sourceId);
+  if (!sourceId) throw routeError(400, ERROR_CODES.VALIDATION_FAILED, "sourceId is required", requestId);
+  return sourceId;
+}
+function providerFromBody(body, requestId) {
+  const provider = parseString(asRecord(body).provider);
+  if (!provider) throw routeError(400, ERROR_CODES.VALIDATION_FAILED, "provider is required", requestId);
+  return provider;
+}
+function registerBoringMcpRoutes(app, options) {
+  const whenDisabled = options.whenDisabled ?? "skip";
+  const enabled = readBoringMcpServerConfig(options.env, { secretEnvVars: options.config.secretEnvVars }).enabled;
+  if (!enabled && whenDisabled === "skip") return;
+  const assertEnabled = (requestId) => {
+    if (!enabled) throw routeError(503, ERROR_CODES.INTERNAL_ERROR, "MCP source routes are disabled for this deployment", requestId);
+  };
+  const routeTransport = options.transport ?? createComposioMcpTransportFor(options.config, options.env);
+  const routeGate = new InMemoryMcpRateBudgetGate({ maxCalls: 100, maxToolCalls: 10, windowMs: 6e4 });
+  function adapterFor(actor) {
+    const registry = createUserSettingsMcpSourceRegistry(app, actor);
+    return {
+      registry,
+      adapter: createBoringMcpManagedConnectorAdapter({ config: options.config, registry, provider: options.provider, env: options.env })
+    };
+  }
+  function handlersFor(actor) {
+    return createBoringMcpSourceHandlers({
+      registry: createUserSettingsMcpSourceRegistry(app, actor),
+      transport: routeTransport,
+      templates: DEFAULT_MCP_PROVIDER_TEMPLATES,
+      hardening: { gate: routeGate, timeoutMs: 3e4 }
+    });
+  }
+  app.get("/api/v1/boring-mcp/sources", async (request) => {
+    assertEnabled(request.id);
+    const actor = await requireBoringMcpActor(app, request);
+    const { registry } = adapterFor(actor);
+    const sources = await registry.listSources(actor);
+    return { sourceStatuses: sources.map(createMcpSourceStatusPayload) };
+  });
+  app.post("/api/v1/boring-mcp/connect", {
+    config: { rateLimit: { ...SOURCE_CONNECT_RATE_LIMIT, keyGenerator: sourceActionRateLimitKey } }
+  }, async (request, reply) => {
+    assertEnabled(request.id);
+    const actor = await requireBoringMcpActor(app, request);
+    const { adapter } = adapterFor(actor);
+    const provider = providerFromBody(request.body, request.id);
+    const result = await withMcpHttpErrors(request.id, () => adapter.startConnect(actor, { provider }));
+    const { connectUrl, ...status } = result;
+    reply.status(201);
+    return { status, connectUrl };
+  });
+  app.post("/api/v1/boring-mcp/refresh", {
+    config: { rateLimit: { ...SOURCE_ACTION_RATE_LIMIT, keyGenerator: sourceActionRateLimitKey } }
+  }, async (request) => {
+    assertEnabled(request.id);
+    const actor = await requireBoringMcpActor(app, request);
+    const { adapter } = adapterFor(actor);
+    const result = await withMcpHttpErrors(request.id, () => adapter.refreshStatus(actor, sourceIdFromBody(request.body, request.id)));
+    return { status: result };
+  });
+  app.post("/api/v1/boring-mcp/disconnect", {
+    config: { rateLimit: { ...SOURCE_ACTION_RATE_LIMIT, keyGenerator: sourceActionRateLimitKey } }
+  }, async (request) => {
+    assertEnabled(request.id);
+    const actor = await requireBoringMcpActor(app, request);
+    const status = await withMcpHttpErrors(request.id, () => adapterFor(actor).adapter.disconnectSource(actor, sourceIdFromBody(request.body, request.id)));
+    return { status };
+  });
+  app.post("/api/v1/boring-mcp/tools", {
+    config: { rateLimit: { ...SOURCE_ACTION_RATE_LIMIT, keyGenerator: sourceActionRateLimitKey } }
+  }, async (request) => {
+    assertEnabled(request.id);
+    const actor = await requireBoringMcpActor(app, request);
+    const body = asRecord(request.body);
+    const result = await withMcpHttpErrors(request.id, () => handlersFor(actor).searchTools(actor, {
+      sourceId: sourceIdFromBody(request.body, request.id),
+      refresh: body.refresh === true
+    }));
+    return { tools: result.tools };
+  });
+}
 
 // src/server/managedConnectorPreflight.ts
 var VENDOR_RISK_FIELDS = [
@@ -1585,6 +1998,7 @@ export {
   assertManagedConnectorPreflight,
   assertMcpPublicPayloadSecretFree,
   assertMcpToolAllowed,
+  boringMcpAgentSessionNamespace,
   classifyMcpTool,
   classifyMcpTools,
   containsMcpCanary,
@@ -1592,6 +2006,9 @@ export {
   containsMcpSecretOrCanary,
   createBoringMcpAgentBridgeRegistry,
   createBoringMcpAgentTools,
+  createBoringMcpAppAgentTools,
+  createBoringMcpAppAgentToolsForRequest,
+  createBoringMcpManagedConnectorAdapter,
   createBoringMcpReadonlyCaller,
   createBoringMcpServerPlugin,
   createBoringMcpSourceHandlers,
@@ -1601,10 +2018,12 @@ export {
   createHardenedMcpTransport,
   createLegacyManagedConnectorSourceId,
   createManagedConnectorAdapter,
+  createManagedConnectorSecretResolver,
   createManagedConnectorSourceId,
   createMcpSchemaHash,
   createMcpSdkStreamableHttpTransport,
   createMcpSourceStatusPayload,
+  createUserSettingsMcpSourceRegistry,
   server_default as default,
   doctorMcpSource,
   evaluateBoringMcpLaunchGate,
@@ -1612,7 +2031,9 @@ export {
   isActorOwnedMcpSource,
   listBoringMcpAgentBridgeTools,
   normalizeMcpCatalogTool,
+  readBoringMcpServerConfig,
   redactMcpSecrets,
+  registerBoringMcpRoutes,
   requireActorOwnedMcpSource,
   resolveComposioMcpSession,
   toMcpSourceDto,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-mcp",
-  "version": "0.1.78",
+  "version": "0.1.79",
   "type": "module",
   "private": false,
   "license": "MIT",
@@ -46,11 +46,14 @@
   },
   "sideEffects": false,
   "peerDependencies": {
+    "fastify": "^5.9.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "@hachej/boring-workspace": "0.1.78"
+    "@hachej/boring-core": "0.1.79",
+    "@hachej/boring-workspace": "0.1.79"
   },
   "devDependencies": {
+    "fastify": "^5.9.0",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.0",
     "@types/node": "^22.20.0",
@@ -63,7 +66,8 @@
     "tsup": "^8.4.0",
     "typescript": "~6.0.3",
     "vitest": "^4.1.9",
-    "@hachej/boring-workspace": "0.1.78"
+    "@hachej/boring-core": "0.1.79",
+    "@hachej/boring-workspace": "0.1.79"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0"