Function discoverTools

packages/plugins/mcp/src/sdk/discover.ts:183–247

(
  connector: McpConnector,
  timeoutMs: number = Duration.toMillis(DEFAULT_DISCOVER_TIMEOUT),
)

 * or the timeout above can still cancel them promptly.
 */
export const discoverTools = (
  connector: McpConnector,
  timeoutMs: number = Duration.toMillis(DEFAULT_DISCOVER_TIMEOUT),
): Effect.Effect<McpToolManifest, McpToolDiscoveryError> =>
  Effect.uninterruptibleMask((restore) =>
    Effect.gen(function* () {
      // Acquire connection
      const connection = yield* restore(
        connector.pipe(
          Effect.mapError((failure) => {
            // Preserve the handshake HTTP status (401/403 = auth wall) and a
            // connect-level timeout so the liveness health check can classify
            // structurally — dropping `failureKind: "timeout"` here is what
            // made a timed-out handshake read as a generic probe failure.
            const httpStatus = Predicate.isTagged(failure, "McpConnectionError")
              ? failure.httpStatus
              : undefined;
            const reauthorizationRequired = Predicate.isTagged(
              failure,
              "McpOAuthReauthorizationRequired",
            );
            const timedOut =
              Predicate.isTagged(failure, "McpConnectionError") &&
              failure.failureKind === "timeout";
            return new McpToolDiscoveryError({
              stage: "connect",
              message: `Failed connecting to MCP server: ${failure.message}`,
              ...(httpStatus !== undefined ? { httpStatus } : {}),
              ...(reauthorizationRequired ? { reauthorizationRequired: true } : {}),
              ...(timedOut ? { timedOut } : {}),
            });
          }),
        ),
      );

      // The connection advertises the elicitation capability (connection.ts),
      // so a server may elicit mid-listTools — the Codex desktop plugins do
      // this for first-use approvals. Discovery has no user to route the
      // request to (unlike the invoke path's bridge in invoke.ts), and a
      // handler-less request would surface as a method-not-found error on the
      // server's side of an otherwise healthy sync. Decline explicitly: the
      // server completes the list with whatever it allows unapproved.
      connection.client.setRequestHandler("elicitation/create", () =>
        Promise.resolve({ action: "decline" }),
      );

      const manifest = yield* restore(listAllTools(connection)).pipe(
        Effect.onExit(() => closeConnection(connection)),
      );

      return manifest;
    }),
  ).pipe(
    Effect.timeoutOrElse({
      duration: Duration.millis(timeoutMs),
      orElse: () =>
        Effect.fail(
          new McpToolDiscoveryError({