@zackbart/connecta 0.8.1 → 0.9.0

package/src/connectors/remote-mcp.ts

@@ -1,13 +1,17 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import {
+  Client,
+  isInputRequiredResult,
+  specTypeSchemas,
+  StreamableHTTPClientTransport,
+  UnauthorizedError,
+} from "@modelcontextprotocol/client";
 import type {
   FetchLike,
+  ListToolsResult,
+  StandardSchemaV1,
+  Tool,
   Transport,
-} from "@modelcontextprotocol/sdk/shared/transport.js";
-import { ListToolsResultSchema } from "@modelcontextprotocol/sdk/types.js";
-import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker";
-import { z } from "zod";
+} from "@modelcontextprotocol/client";
 import { KvOAuthProvider } from "../auth/downstream-oauth.js";
 import { MAX_CATALOG_TOOLS } from "../catalog-limits.js";
 import { ConnectorCallError } from "../errors.js";
@@ -131,36 +135,29 @@ type ListedTool = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
  * end-of-pagination as `null`. Only the cursor is widened; every tool and every
  * other result field still passes through the SDK's pinned schema.
  */
-const CompatibleListToolsResultSchema = ListToolsResultSchema.extend({
-  nextCursor: z.string().nullable().optional(),
-});
-
-/**
- * Re-prime an SDK client's tool-metadata cache from the *full* walked catalog.
- *
- * The SDK's `Client.listTools()` caches one page at a time and **clears** the
- * output-schema validators and task-support sets before each replacement.
- * This walk uses `Client.request()` so it can make the narrow null-cursor
- * compatibility concession above, then primes the metadata exactly once from
- * the complete chain. Otherwise `callTool` would find no validator or task
- * requirement for earlier-page tools and enforcement would depend on where a
- * tool happened to land, which is not enforcement.
- *
- * So hand the whole aggregated list back deliberately, once, at the end. The
- * SDK types the method `private`, hence the cast; the SDK version is pinned
- * exactly and `test/remote-mcp-pagination.test.ts` asserts the method still
- * exists, so a bump that renames it fails CI rather than quietly restoring the
- * bug.
- */
-function primeToolMetadata(client: Client, tools: ListedTool[]): void {
-  const prime = (
-    client as unknown as {
-      cacheToolMetadata?: (tools: ListedTool[]) => void;
-    }
-  ).cacheToolMetadata;
-  if (typeof prime !== "function") return;
-  prime.call(client, tools);
-}
+const CompatibleListToolsResultSchema: StandardSchemaV1<
+  unknown,
+  ListToolsResult
+> = {
+  "~standard": {
+    version: 1,
+    vendor: "connecta",
+    validate(value) {
+      const normalized =
+        typeof value === "object" &&
+        value !== null &&
+        "nextCursor" in value &&
+        value.nextCursor === null
+          ? (() => {
+              const copy = { ...value };
+              delete copy.nextCursor;
+              return copy;
+            })()
+          : value;
+      return specTypeSchemas.ListToolsResult["~standard"].validate(normalized);
+    },
+  },
+};
 
 /**
  * True for a result-parse failure caused by the page's `nextCursor` itself.
@@ -171,13 +168,18 @@ function primeToolMetadata(client: Client, tools: ListedTool[]): void {
  */
 function isCursorShapeError(err: unknown): boolean {
   const issues = (err as { issues?: unknown } | null)?.issues;
-  return (
+  if (
     Array.isArray(issues) &&
     issues.some((issue) => {
       const path = (issue as { path?: unknown }).path;
       return Array.isArray(path) && path[0] === "nextCursor";
     })
-  );
+  ) {
+    return true;
+  }
+  // SDK v2 wraps Standard Schema failures in a ProtocolError and preserves the
+  // failing path in the message rather than exposing the validator's issues.
+  return msg(err).startsWith("Invalid result for tools/list: nextCursor:");
 }
 
 function msg(err: unknown): string {
@@ -393,6 +395,14 @@ export function redirectSafeFetch(
 interface ConnectionState {
   client: Client | null;
   transport: Transport | null;
+  /**
+   * The last complete raw catalog, retained only for this request scope.
+   *
+   * SDK v2 exposes `toolDefinition` as the public call-time seam for output
+   * validation and header mirroring, replacing the v1 private
+   * `cacheToolMetadata` reach-through.
+   */
+  toolDefinitions: Map<string, Tool>;
   connecting: Promise<void> | null;
   authRequired: boolean;
   provider: KvOAuthProvider | null;
@@ -511,6 +521,7 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
       state = {
         client: null,
         transport: null,
+        toolDefinitions: new Map(),
         connecting: null,
         authRequired: false,
         provider: null,
@@ -549,29 +560,23 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
     const url = new URL(opts.url);
     const guardedFetch = redirectSafeFetch(id, opts.redirects);
     if (opts.auth?.type === "oauth") {
-      // The SDK class declares `sessionId` as an own `string | undefined`
-      // property while its Transport interface declares it optional. They are
-      // runtime-compatible; exact optional types only exposes that declaration
-      // mismatch at this boundary.
       return new StreamableHTTPClientTransport(url, {
         authProvider: provider ?? newProvider(ctx),
         fetch: guardedFetch,
-      }) as unknown as Transport;
+      });
     }
     const headers =
       opts.auth?.type === "headers" ? opts.auth.headers : undefined;
-    return new StreamableHTTPClientTransport(
-      url,
-      {
-        ...(headers ? { requestInit: { headers } } : {}),
-        fetch: guardedFetch,
-      },
-    ) as unknown as Transport;
+    return new StreamableHTTPClientTransport(url, {
+      ...(headers ? { requestInit: { headers } } : {}),
+      fetch: guardedFetch,
+    });
   };
 
   const reset = (state: ConnectionState) => {
     state.client = null;
     state.transport = null;
+    state.toolDefinitions.clear();
     state.connecting = null;
     state.authRequired = false;
     state.provider = null;
@@ -652,13 +657,17 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
           throw operatorDisconnectedError();
         }
         provider?.captureGeneration(genAtStart);
-        // The SDK defaults to AJV, which compiles every advertised outputSchema
-        // with `new Function`. Cloudflare Workers prohibit dynamic code
-        // generation, so a remote such as Stripe fails during tools/list unless
-        // the SDK's edge-safe validator is selected explicitly.
+        // SDK v2 selects its validator by runtime export condition: AJV on
+        // Node and @cfworker/json-schema under workerd. The Workers-safe path
+        // no longer needs Connecta-specific wiring.
         const c = new Client(
           { name: "connecta", version: CONNECTA_VERSION },
-          { jsonSchemaValidator: new CfWorkerJsonSchemaValidator() },
+          {
+            versionNegotiation: { mode: "auto" },
+            // Connecta has no interactive relay. Surface the result manually
+            // below as one structured, non-retryable connector failure.
+            inputRequired: { autoFulfill: false },
+          },
         );
         const t = buildTransport(ctx, provider);
         if (!ownsAttempt()) await abandon(t);
@@ -871,9 +880,9 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
           `Connector "${id}" kept advertising more tools/list pages after ${MAX_TOOL_PAGES} — refusing to page further.`,
         );
       }
-      // Repair what the per-page listTools calls left behind before any of
-      // these tools can be called. See primeToolMetadata.
-      primeToolMetadata(client, listed);
+      // Publish definitions only after the full walk succeeds. A later-page
+      // failure must not leave a partial validation/header view behind.
+      state.toolDefinitions = new Map(listed.map((tool) => [tool.name, tool]));
       return listed.map((t) => ({
         name: t.name,
         ...(t.description !== undefined ? { description: t.description } : {}),
@@ -906,14 +915,32 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
       await ensureConnected(ctx, state);
       const client = state.client!;
       try {
-        return await client.callTool(
+        const toolDefinition = state.toolDefinitions.get(name);
+        if (toolDefinition?.execution?.taskSupport === "required") {
+          throw new Error(
+            `Tool "${name}" requires task-based execution, which Connecta does not support.`,
+          );
+        }
+        const result = await client.callTool(
           {
             name,
             arguments: (args ?? {}) as Record<string, unknown>,
           },
-          undefined,
-          requestOptions(ctx),
+          {
+            ...requestOptions(ctx),
+            allowInputRequired: true,
+            ...(toolDefinition ? { toolDefinition } : {}),
+          },
         );
+        if (isInputRequiredResult(result)) {
+          throw new ConnectorCallError(
+            "input_required_unsupported",
+            `Connector "${id}" returned input_required for "${name}". ` +
+              "Connecta cannot relay multi-round-trip input yet; this " +
+              "capability is gated pending real host and downstream adoption.",
+          );
+        }
+        return result;
       } catch (err) {
         // A grant revoked after connect surfaces here, not in ensureConnected.
         if (err instanceof UnauthorizedError) {
@@ -939,6 +966,7 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
       const transport = state.transport;
       state.client = null;
       state.transport = null;
+      state.toolDefinitions.clear();
       state.connecting = null;
       state.authRequired = false;
       state.connectedGeneration = null;
@@ -979,7 +1007,7 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
       }
     },
 
-    async finishAuth(code, ctx) {
+    async finishAuth(code, ctx, callbackParams) {
       const state = stateFor(ctx);
       const provider = getProvider(ctx, state);
       // verifyState ran on this request-scoped provider first and captured the
@@ -987,7 +1015,11 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
       // token write remains tagged with that older generation and is unreadable.
       const t = (state.transport ??
         buildTransport(ctx, provider)) as StreamableHTTPClientTransport;
-      await t.finishAuth(code);
+      if (callbackParams !== undefined) {
+        await t.finishAuth(callbackParams);
+      } else {
+        await t.finishAuth(code);
+      }
       await provider.clearPending();
       // Reset so the next use reconnects with the freshly stored tokens.
       reset(state);

package/src/errors.ts

@@ -8,6 +8,7 @@ export type ConnectorCallErrorCode =
   | "rate_limited"
   | "unavailable"
   | "invalid_args"
+  | "input_required_unsupported"
   | "connector_call_failed";
 
 /** Agent-visible recovery class attached only to `auth_required` failures. */
@@ -22,6 +23,7 @@ const RETRYABLE_BY_CODE: Record<ConnectorCallErrorCode, boolean> = {
   unavailable: true,
   auth_required: false,
   invalid_args: false,
+  input_required_unsupported: false,
   connector_call_failed: false,
 };
 

package/src/execute.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpServer } from "@modelcontextprotocol/server";
 import { z } from "zod";
 import type { ActivityRequestContext } from "./activity.js";
 import {
@@ -150,6 +150,7 @@ export async function buildSandboxProviders(
     maxHostCalls?: number;
     hostCallTimeoutMs?: number;
     discoveryConcurrency?: number;
+    onInvocationFailure?: (failure: InvocationFailure) => void;
   } = {},
 ): Promise<ExecutorProvider[]> {
   // All host calls made by one execute_code invocation share a downstream
@@ -210,7 +211,11 @@ export async function buildSandboxProviders(
       args ?? {},
       invocationContext(),
     );
-    if (!outcome.ok) throw new InvocationFailure(outcome.error);
+    if (!outcome.ok) {
+      const failure = new InvocationFailure(outcome.error);
+      limits.onInvocationFailure?.(failure);
+      throw failure;
+    }
     return outcome.value;
   };
   const callNamespace = async (
@@ -225,7 +230,11 @@ export async function buildSandboxProviders(
       args ?? {},
       invocationContext(),
     );
-    if (!outcome.ok) throw new InvocationFailure(outcome.error);
+    if (!outcome.ok) {
+      const failure = new InvocationFailure(outcome.error);
+      limits.onInvocationFailure?.(failure);
+      throw failure;
+    }
     return outcome.value;
   };
 
@@ -317,6 +326,7 @@ export function createExecuteTool(
     }
     let lease;
     let outcome;
+    const invocationFailures: InvocationFailure[] = [];
     try {
       // Admission comes before provider construction: queued calls retain no
       // catalogs, request scopes, or one-closure-per-tool provider arrays.
@@ -335,6 +345,9 @@ export function createExecuteTool(
         activity,
         {
           signal: controller.signal,
+          onInvocationFailure: (failure) => {
+            invocationFailures.push(failure);
+          },
           ...(config.discoveryConcurrency !== undefined
             ? { discoveryConcurrency: config.discoveryConcurrency }
             : {}),
@@ -386,6 +399,27 @@ export function createExecuteTool(
           )
         : undefined;
     if (outcome.error) {
+      // Executor bridges necessarily reduce thrown host errors to strings.
+      // Match that terminal string back to the request-local typed failure so
+      // an unhandled tool failure keeps the same structured contract as
+      // call_tool and batch_call. Failures caught by model code never reach
+      // outcome.error and therefore remain under that code's control.
+      let invocationFailure: InvocationFailure | undefined;
+      for (let i = invocationFailures.length - 1; i >= 0; i--) {
+        const candidate = invocationFailures[i];
+        if (candidate && outcome.error.includes(candidate.message)) {
+          invocationFailure = candidate;
+          break;
+        }
+      }
+      if (invocationFailure) {
+        const result = jsonResult({
+          error: invocationFailure.details,
+          ...(logs ? { logs } : {}),
+        });
+        result.isError = true;
+        return result;
+      }
       return errorResult(
         `Error: ${outcome.error}${logs ? `\n\nLogs:\n${logs}` : ""}`,
       );
@@ -448,11 +482,11 @@ export function registerExecuteTool(
     "execute_code",
     {
       description: EXECUTE_DESC,
-      inputSchema: {
+      inputSchema: z.object({
         code: z
           .string()
           .describe("A JavaScript async arrow function to execute."),
-      },
+      }),
       // The sandbox exposes only tools that are explicitly read-only, and the
       // executor grants no network, filesystem, env, or timer capabilities.
       annotations: {
@@ -463,7 +497,7 @@ export function registerExecuteTool(
     },
     async (args, extra) => {
       const controller = new AbortController();
-      const signals = [extra.signal, ctx.requestSignal].filter(
+      const signals = [extra.mcpReq.signal, ctx.requestSignal].filter(
         (signal): signal is AbortSignal => signal !== undefined,
       );
       const forwarders = signals.map((signal) => {

package/src/meta-tools.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpServer } from "@modelcontextprotocol/server";
 import { z } from "zod";
 import type {
   ActivityCallSource,
@@ -611,6 +611,7 @@ export function createMetaTools(
     if (!outcome.ok) {
       const failedResult =
         outcome.error.code === "auth_required" ||
+        outcome.error.code === "input_required_unsupported" ||
         call.resultMode === "value"
           ? jsonResult({
               ok: false,
@@ -620,7 +621,10 @@ export function createMetaTools(
               ...(call.diagnostics ? { timing: outcome.timing } : {}),
             })
           : errorResult(outcome.error.message);
-      if (outcome.error.code === "auth_required") {
+      if (
+        outcome.error.code === "auth_required" ||
+        outcome.error.code === "input_required_unsupported"
+      ) {
         failedResult.isError = true;
       }
       return {
@@ -1222,7 +1226,7 @@ export function registerMetaTools(
     "skills",
     {
       description: describedFor(registry, SKILLS_DESC, "skills"),
-      inputSchema: { name: z.string().optional() },
+      inputSchema: z.object({ name: z.string().optional() }),
       annotations: READ_ONLY_LOCAL,
     },
     async (args) => mt.skills(args as SkillArgs),
@@ -1232,7 +1236,7 @@ export function registerMetaTools(
     "list_connectors",
     {
       description: LIST_DESC,
-      inputSchema: { probe: z.boolean().optional() },
+      inputSchema: z.object({ probe: z.boolean().optional() }),
       annotations: READ_ONLY_REMOTE,
     },
     async (args) => mt.listConnectors(args as ListArgs),
@@ -1242,14 +1246,14 @@ export function registerMetaTools(
     "search_tools",
     {
       description: describedFor(registry, SEARCH_DESC, "search"),
-      inputSchema: {
+      inputSchema: z.object({
         query: z.string().optional(),
         connector: z.string().optional(),
         limit: z.number().int().positive().max(MAX_SEARCH_LIMIT).optional(),
         offset: z.number().int().nonnegative().optional(),
         fullDescriptions: z.boolean().optional(),
         includeSchemas: z.enum(["compact", "json"]).optional(),
-      },
+      }),
       annotations: READ_ONLY_REMOTE,
     },
     async (args) => mt.searchTools(args as SearchArgs),
@@ -1259,11 +1263,11 @@ export function registerMetaTools(
     "describe_tools",
     {
       description: describedFor(registry, DESCRIBE_DESC, "describe"),
-      inputSchema: {
+      inputSchema: z.object({
         addresses: z.array(z.string()).max(MAX_DESCRIBE_ADDRESSES),
         format: z.enum(["compact", "json"]).optional(),
         fullDescriptions: z.boolean().optional(),
-      },
+      }),
       annotations: READ_ONLY_REMOTE,
     },
     async (args) => mt.describeTools(args as DescribeArgs),
@@ -1273,7 +1277,7 @@ export function registerMetaTools(
     "call_tool",
     {
       description: CALL_DESC,
-      inputSchema: CALL_INPUT_SCHEMA,
+      inputSchema: z.object(CALL_INPUT_SCHEMA),
       // call_tool admits only tools that are themselves explicitly read-only;
       // anything else is refused and routed to call_destructive_tool.
       annotations: READ_ONLY_REMOTE,
@@ -1285,7 +1289,7 @@ export function registerMetaTools(
     "call_destructive_tool",
     {
       description: CALL_DESTRUCTIVE_DESC,
-      inputSchema: CALL_INPUT_SCHEMA,
+      inputSchema: z.object(CALL_INPUT_SCHEMA),
       annotations: {
         destructiveHint: true,
         readOnlyHint: false,
@@ -1299,10 +1303,10 @@ export function registerMetaTools(
     "authorize_connector",
     {
       description: AUTHORIZE_DESC,
-      inputSchema: {
+      inputSchema: z.object({
         connector: z.string(),
         force: z.boolean().optional(),
-      },
+      }),
       // Starts (or with force, resets) a downstream OAuth flow — it changes
       // stored connector auth state, so it is deliberately not read-only.
       annotations: {
@@ -1318,7 +1322,7 @@ export function registerMetaTools(
     "get_result",
     {
       description: GET_RESULT_DESC,
-      inputSchema: {
+      inputSchema: z.object({
         id: z.string(),
         // Both bounds are the shared rules (isValidResultOffset,
         // isValidMaxResultBytes) expressed for the wire: spelling them against
@@ -1326,7 +1330,7 @@ export function registerMetaTools(
         // in-handler checks if either floor ever moves.
         offset: z.number().int().min(MIN_RESULT_OFFSET).optional(),
         maxBytes: z.number().int().min(MIN_MAX_RESULT_BYTES).optional(),
-      },
+      }),
       annotations: READ_ONLY_LOCAL,
     },
     async (args) => mt.getResult(args as GetResultArgs),
@@ -1336,7 +1340,7 @@ export function registerMetaTools(
     "batch_call",
     {
       description: BATCH_DESC,
-      inputSchema: {
+      inputSchema: z.object({
         calls: z
           .array(z.object(CALL_INPUT_SCHEMA))
           .min(1)
@@ -1345,7 +1349,7 @@ export function registerMetaTools(
         timeoutMs: z.number().int().positive().optional(),
         maxRetries: z.number().int().min(0).max(2).optional(),
         diagnostics: z.boolean().optional(),
-      },
+      }),
       // Same gate as call_tool: every call in the batch must be explicitly
       // read-only or the batch is refused.
       annotations: READ_ONLY_REMOTE,

package/src/routes/mcp.ts

@@ -1,5 +1,9 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import {
+  createMcpHandler,
+  isLegacyRequest,
+  McpServer,
+  WebStandardStreamableHTTPServerTransport,
+} from "@modelcontextprotocol/server";
 import type { ActivityActor, ActivityRequestContext } from "../activity.js";
 import { registerExecuteTool } from "../execute.js";
 import {
@@ -21,7 +25,7 @@ export const MCP_CORS_HEADERS = {
   "Access-Control-Allow-Origin": "*",
   "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
   "Access-Control-Allow-Headers":
-    "Content-Type, Authorization, mcp-protocol-version, mcp-session-id",
+    "Content-Type, Authorization, mcp-protocol-version, mcp-session-id, mcp-method, mcp-name",
 };
 
 // Browser-based MCP clients call /mcp cross-origin. Without CORS on every
@@ -188,54 +192,76 @@ async function serveMcp(
   registry: RegistryView,
   runtimeContext?: RuntimeExecutionContext,
 ): Promise<Response> {
-  // Fresh McpServer + transport per request (SDK ≥1.26 requirement), stateless.
-  const server = new McpServer(opts.serverInfo, {
-    instructions: CONNECTA_INSTRUCTIONS,
-  });
-  const activity: ActivityRequestContext | undefined = opts.activity
-    ? {
-        sink: opts.activity,
-        actor,
-        requestId: crypto.randomUUID(),
-        serverInfo: opts.serverInfo,
-        ...(opts.activityDeploymentId
-          ? { deploymentId: opts.activityDeploymentId }
-          : {}),
-        ...(runtimeContext?.waitUntil
-          ? { defer: runtimeContext.waitUntil.bind(runtimeContext) }
-          : {}),
-        logger: opts.logger,
-      }
-    : undefined;
-  registerMetaTools(server, registry, {
-    baseUrl,
-    ...(activity ? { activity } : {}),
-    ...(opts.defaultToolTimeoutMs !== undefined
-      ? { defaultToolTimeoutMs: opts.defaultToolTimeoutMs }
-      : {}),
-    ...(opts.probeTimeoutMs !== undefined
-      ? { probeTimeoutMs: opts.probeTimeoutMs }
-      : {}),
-    ...(opts.discoveryConcurrency !== undefined
-      ? { discoveryConcurrency: opts.discoveryConcurrency }
-      : {}),
-    requestSignal: request.signal,
-    ...(runtimeContext
-      ? { defer: runtimeContext.waitUntil.bind(runtimeContext) }
-      : {}),
-  });
-  if (opts.executor) {
-    registerExecuteTool(server, registry, {
+  const createServer = (): McpServer => {
+    const server = new McpServer(opts.serverInfo, {
+      instructions: CONNECTA_INSTRUCTIONS,
+      cacheHints: {
+        "tools/list": {
+          ttlMs: 3_600_000,
+          cacheScope: "private",
+        },
+      },
+    });
+    const activity: ActivityRequestContext | undefined = opts.activity
+      ? {
+          sink: opts.activity,
+          actor,
+          requestId: crypto.randomUUID(),
+          serverInfo: opts.serverInfo,
+          ...(opts.activityDeploymentId
+            ? { deploymentId: opts.activityDeploymentId }
+            : {}),
+          ...(runtimeContext?.waitUntil
+            ? { defer: runtimeContext.waitUntil.bind(runtimeContext) }
+            : {}),
+          logger: opts.logger,
+        }
+      : undefined;
+    registerMetaTools(server, registry, {
       baseUrl,
-      executor: opts.executor,
-      logger: opts.logger,
       ...(activity ? { activity } : {}),
-      requestSignal: request.signal,
+      ...(opts.defaultToolTimeoutMs !== undefined
+        ? { defaultToolTimeoutMs: opts.defaultToolTimeoutMs }
+        : {}),
+      ...(opts.probeTimeoutMs !== undefined
+        ? { probeTimeoutMs: opts.probeTimeoutMs }
+        : {}),
       ...(opts.discoveryConcurrency !== undefined
         ? { discoveryConcurrency: opts.discoveryConcurrency }
         : {}),
+      requestSignal: request.signal,
+      ...(runtimeContext
+        ? { defer: runtimeContext.waitUntil.bind(runtimeContext) }
+        : {}),
     });
+    if (opts.executor) {
+      registerExecuteTool(server, registry, {
+        baseUrl,
+        executor: opts.executor,
+        logger: opts.logger,
+        ...(activity ? { activity } : {}),
+        requestSignal: request.signal,
+        ...(opts.discoveryConcurrency !== undefined
+          ? { discoveryConcurrency: opts.discoveryConcurrency }
+          : {}),
+      });
+    }
+    return server;
+  };
+
+  // The v2 entry's built-in legacy fallback streams 2025 results as SSE.
+  // Connecta's established wire contract is JSON, so retain the documented
+  // user-land legacy branch with the same transport setting while the modern
+  // branch uses the fetch-native handler.
+  if (!(await isLegacyRequest(request))) {
+    return createMcpHandler(createServer, {
+      legacy: "reject",
+      onerror: (error) => opts.logger.error("[connecta] MCP handler error", error),
+    }).fetch(request);
   }
+
+  // Fresh server + transport per legacy request, stateless and JSON-shaped.
+  const server = createServer();
   const transport = new WebStandardStreamableHTTPServerTransport({
     enableJsonResponse: true,
   });

package/src/routes/oauth.ts

@@ -309,7 +309,7 @@ export async function routeOAuthCallback(
     return refused();
   }
   try {
-    await connector.finishAuth(code, connectorContext);
+    await connector.finishAuth(code, connectorContext, url.searchParams);
     await opts.registry.invalidateStored(id);
     return html(
       `Connected "${id}". You can close this window.`,